pax_global_header00006660000000000000000000000064131244456420014517gustar00rootroot0000000000000052 comment=04c1ea6040afd876f31a143431d1aa42aaab3728 libzim-2.0.0/000077500000000000000000000000001312444564200130045ustar00rootroot00000000000000libzim-2.0.0/.gitignore000066400000000000000000000005061312444564200147750ustar00rootroot00000000000000*~ *#* autom4te.cache compile config.h configure depcomp .deps .dirstamp INSTALL install-sh *.kate-swp *.la .libs libtool *.lo ltmain.sh *.m4 Makefile Makefile.in missing *.o stamp-h1 .svn .*.swp *.zim examples/createZimExample src/tools/zimdump src/tools/zimsearch libzim.pc test-driver test/zimlib-test* test/test-suite.log libzim-2.0.0/.travis.yml000066400000000000000000000004171312444564200151170ustar00rootroot00000000000000language: cpp dist: trusty sudo: required cache: ccache install: travis/install_deps.sh script: travis/compile.sh env: - PLATFORM="native_static" - PLATFORM="native_dyn" - PLATFORM="win32_static" - PLATFORM="win32_dyn" - PLATFORM="android_arm" - PLATFORM="android_arm64" libzim-2.0.0/AUTHORS000066400000000000000000000000431312444564200140510ustar00rootroot00000000000000Tommi Maekitalo libzim-2.0.0/COPYING000066400000000000000000000354341312444564200140500ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS libzim-2.0.0/ChangeLog000066400000000000000000000013421312444564200145560ustar00rootroot00000000000000 libzim 2.0.0 ============ * Move to meson build system `libzim` now use `meson` as build system instead of `autotools` * Move to C++11 standard. * Fulltext search in zim file. We have integrated the xapian fulltext search in libzim. So now, libzim provide an API to search in a zim containing embeded fulltext index. This means that : *libzim need xapian as (optional) dependencies (if you want compile with xapian support). * The old and unused search API has been removed. * Remove bzip2 support. * Remove Symbian support. * Few API hanges * Make some header files private (not installed); * A `Blob` can now be cast to a `string` directly; * Change a lot of `File` methods to const methods. libzim-2.0.0/README.md000066400000000000000000000070641312444564200142720ustar00rootroot00000000000000ZIM library ============= The ZIM library is the reference implementation for the ZIM file format. It's a solution to read and write ZIM files on many systems and architectures. More information about the ZIM format and the openZIM project at http://www.openzim.org/ Disclaimer ---------- This document assumes you have a little knowledge about software compilation. If you experience difficulties with the dependencies or with the ZIM libary compilation itself, we recommend to have a look to [kiwix-build](https://github.com/kiwix/kiwix-build). Preamble -------- Although the ZIM library can be compiled/cross-compiled on/for many sytems, the following documentation explains how to do it on POSIX ones. It is primarly though for GNU/Linux systems and has been tested on recent releases of Ubuntu and Fedora. Dependencies ------------ The Kiwix library relies on many third parts software libraries. They are prerequisites to the Kiwix library compilation. Following libraries need to be available: * Z ................................................. http://zlib.net/ (package zlib1g-dev on Ubuntu) * Lzma ...................................... http://tukaani.org/lzma/ (package lzma-dev on Ubuntu) * ICU ................................... http://site.icu-project.org/ (package libicu-dev on Ubuntu) * Xapian ......................................... https://xapian.org/ (package libxapian-dev on Ubuntu) These dependencies may or may not be packaged by your operating system. They may also be packaged but only in an older version. The compilation script will tell you if one of them is missing or too old. In the worse case, you will have to download and compile a more recent version by hand. If you want to install these dependencies locally, then ensure that meson (through pkg-config) will properly find them. Environnement ------------- The ZIM library builds using [Meson](http://mesonbuild.com/) version 0.39 or higher. Meson relies itself on Ninja, pkg-config and few other compilation tools. Install first the few common compilation tools: * Automake * Libtool * Virtualenv * Pkg-config Then install Meson itself: ``` virtualenv -p python3 ./ # Create virtualenv source bin/activate # Activate the virtualenv pip3 install meson # Install Meson hash -r # Refresh bash paths ``` Finally we need the Ninja tool (available in the $PATH). Here is a solution to download, build and install it locally: ``` git clone git://github.com/ninja-build/ninja.git cd ninja git checkout release ./configure.py --bootstrap mkdir ../bin cp ninja ../bin cd .. ``` Compilation ----------- Once all dependencies are installed, you can compile ZIM library with: ``` mkdir build meson . build cd build ninja ``` By default, it will compile dynamic linked libraries. If you want statically linked libraries, you can add `--default-library=static` option to the Meson command. Depending of you system, `ninja` may be called `ninja-build`. Installation ------------ If you want to install the libzim and the headers you just have compiled on your system, here we go: ``` ninja install # You have to be in the "build" directory ``` You might need to run the command as root (or using 'sudo'), depending where you want to install the libraries. After the installation succeeded, you may need to run ldconfig (as root). Uninstallation ------------ If you want to uninstall the libzim: ``` ninja uninstall # You have to be in the "build" directory ``` Like for the installation, you might need to run the command as root (or using 'sudo'). License ------- GPLv2, see COPYING for more details.libzim-2.0.0/examples/000077500000000000000000000000001312444564200146225ustar00rootroot00000000000000libzim-2.0.0/examples/createZimExample.cpp000066400000000000000000000056111312444564200205700ustar00rootroot00000000000000/* * Copyright (C) 2012 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #include #include #include class TestArticle : public zim::writer::Article { std::string _id; std::string _data; public: TestArticle() { } explicit TestArticle(const std::string& id); virtual std::string getAid() const; virtual char getNamespace() const; virtual std::string getUrl() const; virtual std::string getTitle() const; virtual bool isRedirect() const; virtual std::string getMimeType() const; virtual std::string getRedirectAid() const; virtual zim::Blob getData() const { return zim::Blob(&_data[0], _data.size()); } }; TestArticle::TestArticle(const std::string& id) : _id(id) { std::ostringstream data; data << "this is article " << id << std::endl; _data = data.str(); } std::string TestArticle::getAid() const { return _id; } char TestArticle::getNamespace() const { return 'A'; } std::string TestArticle::getUrl() const { return _id; } std::string TestArticle::getTitle() const { return _id; } bool TestArticle::isRedirect() const { return false; } std::string TestArticle::getMimeType() const { return "text/plain"; } std::string TestArticle::getRedirectAid() const { return ""; } class TestArticleSource : public zim::writer::ArticleSource { std::vector _articles; unsigned _next; public: explicit TestArticleSource(unsigned max = 16); virtual const zim::writer::Article* getNextArticle(); }; TestArticleSource::TestArticleSource(unsigned max) : _next(0) { _articles.resize(max); for (unsigned n = 0; n < max; ++n) { std::ostringstream id; id << (n + 1); _articles[n] = TestArticle(id.str()); } } const zim::writer::Article* TestArticleSource::getNextArticle() { if (_next >= _articles.size()) return 0; unsigned n = _next++; return &_articles[n]; } int main(int argc, char* argv[]) { try { zim::writer::ZimCreator c(argc, argv); TestArticleSource src; c.create("foo.zim", src); } catch (const std::exception& e) { std::cerr << e.what() << std::endl; } } libzim-2.0.0/examples/meson.build000066400000000000000000000003151312444564200167630ustar00rootroot00000000000000 executable('createZimExample', 'createZimExample.cpp', link_with: libzim, include_directories: include_directory, dependencies: [xapian_dep, icu_dep, zlib_dep, lzma_dep]) libzim-2.0.0/include/000077500000000000000000000000001312444564200144275ustar00rootroot00000000000000libzim-2.0.0/include/meson.build000066400000000000000000000011611312444564200165700ustar00rootroot00000000000000include_directory = include_directories('.') install_headers( 'zim/article.h', 'zim/blob.h', 'zim/cache.h', 'zim/cluster.h', 'zim/dirent.h', 'zim/error.h', 'zim/file.h', 'zim/fileheader.h', 'zim/fileimpl.h', 'zim/fileiterator.h', 'zim/fstream.h', 'zim/noncopyable.h', 'zim/search.h', 'zim/search_iterator.h', 'zim/smartptr.h', 'zim/refcounted.h', 'zim/template.h', 'zim/uuid.h', 'zim/zim.h', subdir:'zim' ) install_headers( 'zim/writer/articlesource.h', 'zim/writer/dirent.h', 'zim/writer/zimcreator.h', subdir:'zim/writer' ) libzim-2.0.0/include/zim/000077500000000000000000000000001312444564200152265ustar00rootroot00000000000000libzim-2.0.0/include/zim/article.h000066400000000000000000000074161312444564200170320ustar00rootroot00000000000000/* * Copyright (C) 2006 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_ARTICLE_H #define ZIM_ARTICLE_H #include #include #include #include #include #include #include namespace zim { class Article { private: File file; size_type idx; public: Article() : idx(std::numeric_limits::max()) { } Article(const File& file_, size_type idx_) : file(file_), idx(idx_) { } Dirent getDirent() const { return const_cast(file).getDirent(idx); } std::string getParameter() const { return getDirent().getParameter(); } std::string getTitle() const { return getDirent().getTitle(); } std::string getUrl() const { return getDirent().getUrl(); } std::string getLongUrl() const { return getDirent().getLongUrl(); } uint16_t getLibraryMimeType() const { return getDirent().getMimeType(); } const std::string& getMimeType() const { return file.getMimeType(getLibraryMimeType()); } bool isRedirect() const { return getDirent().isRedirect(); } bool isLinktarget() const { return getDirent().isLinktarget(); } bool isDeleted() const { return getDirent().isDeleted(); } char getNamespace() const { return getDirent().getNamespace(); } size_type getRedirectIndex() const { return getDirent().getRedirectIndex(); } Article getRedirectArticle() const { return Article(file, getRedirectIndex()); } size_type getArticleSize() const; bool operator< (const Article& a) const { return getNamespace() < a.getNamespace() || (getNamespace() == a.getNamespace() && getTitle() < a.getTitle()); } Cluster getCluster() const { return file.getCluster(getDirent().getClusterNumber()); } Blob getData() const { Dirent dirent = getDirent(); return dirent.isRedirect() || dirent.isLinktarget() || dirent.isDeleted() ? Blob() : const_cast(file).getBlob(dirent.getClusterNumber(), dirent.getBlobNumber()); } offset_type getOffset() const { Dirent dirent = getDirent(); return dirent.isRedirect() || dirent.isLinktarget() || dirent.isDeleted() ? 0 : const_cast(file).getOffset(dirent.getClusterNumber(), dirent.getBlobNumber()); } std::string getPage(bool layout = true, unsigned maxRecurse = 10); void getPage(std::ostream&, bool layout = true, unsigned maxRecurse = 10); const File& getFile() const { return file; } File& getFile() { return file; } size_type getIndex() const { return idx; } bool good() const { return idx != std::numeric_limits::max(); } }; } #endif // ZIM_ARTICLE_H libzim-2.0.0/include/zim/blob.h000066400000000000000000000036551312444564200163260ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_BLOB_H #define ZIM_BLOB_H #include #include #include #include namespace zim { class Blob { const char* _data; unsigned _size; SmartPtr _cluster; public: Blob() : _data(0), _size(0) { } Blob(const char* data, unsigned size) : _data(data), _size(size) { } Blob(ClusterImpl* cluster, const char* data, unsigned size) : _data(data), _size(size), _cluster(cluster) { } operator std::string() const { return std::string(_data, _size); } const char* data() const { return _data; } const char* end() const { return _data + _size; } unsigned size() const { return _size; } }; inline std::ostream& operator<< (std::ostream& out, const Blob& blob) { if (blob.data()) out.write(blob.data(), blob.size()); return out; } inline bool operator== (const Blob& b1, const Blob& b2) { return b1.size() == b2.size() && std::equal(b1.data(), b1.data() + b1.size(), b2.data()); } } #endif // ZIM_BLOB_H libzim-2.0.0/include/zim/cache.h000066400000000000000000000253211312444564200164450ustar00rootroot00000000000000/* * Copyright (C) 2008 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_CACHE_H #define ZIM_CACHE_H #include #include #include #ifdef _WIN32 #define NOMINMAX #include #undef NOMINMAX #undef max #endif namespace zim { /** Implements a container for caching elements. The cache holds a list of key-value-pairs. There are 2 main operations for accessing the cache: put and get. Put takes a key and a value and puts the element into the list. Get takes a key and optional a value. If the value for the key is found, it is returned. The passed value otherwise. By default the value is constructed with the empty ctor of the value-type. The cache has a maximum size, after which key-value-pairs are dropped, when a new item is put into the cache. The algorithm for this cache is as follows: - when the cache is not full, new elements are appended - new elements are put into the middle of the list otherwise - the last element of the list is then dropped - when getting a value and the value is found, it is put to the beginning of the list When elements are searched, a linear search is done using the ==-operator of the key type. The caching algorithm keeps elements, which are fetched more than once in the first half of the list. In the second half the elements are either new or the elements are pushed from the first half to the second half by other elements, which are found in the cache. You should be aware, that the key type should be simple. Comparing keys must be cheap. Copying elements (both key and value) must be possible and should be cheap, since they are moved in the underlying container. */ template class Cache { struct Data { bool winner; unsigned serial; Value value; Data() { } Data(bool winner_, unsigned serial_, const Value& value_) : winner(winner_), serial(serial_), value(value_) { } }; typedef std::map DataType; DataType data; typename DataType::size_type maxElements; unsigned serial; unsigned hits; unsigned misses; unsigned _nextSerial() { if (serial == std::numeric_limits::max()) { for (typename DataType::iterator it = data.begin(); it != data.end(); ++it) it->second.serial = 0; serial = 1; } return serial++; } typename DataType::iterator _getOldest(bool winner) { typename DataType::iterator foundElement = data.begin(); typename DataType::iterator it = data.begin(); for (++it; it != data.end(); ++it) if (it->second.winner == winner && (foundElement->second.winner != winner || it->second.serial < foundElement->second.serial)) foundElement = it; return foundElement; } typename DataType::iterator _getNewest(bool winner) { typename DataType::iterator foundElement = data.begin(); typename DataType::iterator it = data.begin(); for (++it; it != data.end(); ++it) if (it->second.winner == winner && (foundElement->second.winner != winner || it->second.serial > foundElement->second.serial)) foundElement = it; return foundElement; } // drop one element void _dropLooser() { // look for the oldest element in the list of loosers to drop it data.erase(_getOldest(false)); } void _makeLooser() { // look for the oldest element in the list of winners to make it a looser typename DataType::iterator it = _getOldest(true); it->second.winner = false; it->second.serial = _nextSerial(); } public: typedef typename DataType::size_type size_type; typedef Value value_type; explicit Cache(size_type maxElements_) : maxElements(maxElements_ + (maxElements_ & 1)), serial(0), hits(0), misses(0) { } /// returns the number of elements currently in the cache size_type size() const { return data.size(); } /// returns the maximum number of elements in the cache size_type getMaxElements() const { return maxElements; } void setMaxElements(size_type maxElements_) { size_type numWinners = size() < maxElements / 2 ? size() : maxElements / 2; maxElements_ += (maxElements_ & 1); if (maxElements_ > maxElements) { maxElements = maxElements_; while (numWinners < maxElements / 2) { _getNewest(false)->winner = true; ++numWinners; } } else { while (maxElements > maxElements_) { _dropLooser(); _dropLooser(); _makeLooser(); maxElements -= 2; } while (numWinners > maxElements / 2) { _getNewest(true)->winner = false; --numWinners; } } } /// removes a element from the cache and returns true, if found bool erase(const Key& key) { typename DataType::iterator it = data.find(key); if (it == data.end()) return false; if (it->second.winner) _getNewest(false)->winner=true; data.erase(it); return true; } /// clears the cache. void clear(bool stats = false) { data.clear(); if (stats) hits = misses = 0; } /// puts a new element in the cache. If the element is already found in /// the cache, it is considered a cache hit and pushed to the top of the /// list. void put(const Key& key, const Value& value) { typename DataType::iterator it; if (data.size() < maxElements) { data.insert(data.begin(), typename DataType::value_type(key, Data(data.size() < maxElements / 2, _nextSerial(), value))); } else if ((it = data.find(key)) == data.end()) { // element not found _dropLooser(); data.insert(data.begin(), typename DataType::value_type(key, Data(false, _nextSerial(), value))); } else { // element found it->second.serial = _nextSerial(); if (!it->second.winner) { // move element to the winner part it->second.winner = true; _makeLooser(); } } } /// puts a new element on the top of the cache. If the element is already /// found in the cache, it is considered a cache hit and pushed to the /// top of the list. This method actually overrides the need, that a element /// needs a hit to get to the top of the cache. void put_top(const Key& key, const Value& value) { typename DataType::iterator it; if (data.size() < maxElements) { if (data.size() >= maxElements / 2) _makeLooser(); data.insert(data.begin(), typename DataType::value_type(key, Data(true, _nextSerial(), value))); } else if ((it = data.find(key)) == data.end()) { // element not found _dropLooser(); _makeLooser(); data.insert(data.begin(), typename DataType::value_type(key, Data(true, _nextSerial(), value))); } else { // element found it->second.serial = _nextSerial(); if (!it->second.winner) { // move element to the winner part it->second.winner = true; _makeLooser(); } } } Value* getptr(const Key& key) { typename DataType::iterator it = data.find(key); if (it == data.end()) return 0; it->second.serial = _nextSerial(); if (!it->second.winner) { // move element to the winner part it->second.winner = true; _makeLooser(); } return &it->second.value; } /// returns a pair of values - a flag, if the value was found and the /// value if found or the passed default otherwise. If the value is /// found it is a cahce hit and pushed to the top of the list. std::pair getx(const Key& key, Value def = Value()) { Value* v = getptr(key); return v ? std::pair(true, *v) : std::pair(false, def); } /// returns the value to a key or the passed default value if not found. /// If the value is found it is a cahce hit and pushed to the top of the /// list. Value get(const Key& key, Value def = Value()) { return getx(key, def).second; } /// returns the number of hits. unsigned getHits() const { return hits; } /// returns the number of misses. unsigned getMisses() const { return misses; } /// returns the cache hit ratio between 0 and 1. double hitRatio() const { return hits+misses > 0 ? static_cast(hits)/static_cast(hits+misses) : 0; } /// returns the ratio, between held elements and maximum elements. double fillfactor() const { return static_cast(data.size()) / static_cast(maxElements); } /* void dump(std::ostream& out) const { out << "cache max size=" << maxElements << " current size=" << size() << '\n'; for (typename DataType::const_iterator it = data.begin(); it != data.end(); ++it) { out << "\tkey=\"" << it->first << "\" value=\"" << it->second.value << "\" serial=" << it->second.serial << " winner=" << it->second.winner << '\n'; } out << "--------\n"; } */ }; } #endif // ZIM_CACHE_H libzim-2.0.0/include/zim/cluster.h000066400000000000000000000105431312444564200170630ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_CLUSTER_H #define ZIM_CLUSTER_H #include #include #include #include #include #include namespace zim { class Blob; class Cluster; class ClusterImpl : public RefCounted { friend std::ostream& operator<< (std::ostream& out, const ClusterImpl& blobImpl); typedef std::vector Offsets; typedef std::vector Data; CompressionType compression; Offsets offsets; Data _data; offset_type startOffset; ifstream* lazy_read_stream; offset_type read_header(std::istream& in); void read_content(std::istream& in); void write(std::ostream& out) const; void set_lazy_read(ifstream* in) { lazy_read_stream = in; } bool is_fully_initialised() const { return lazy_read_stream == 0; } void finalise_read(); const Data& data() const { if ( !is_fully_initialised() ) { const_cast(this)->finalise_read(); } return _data; } public: ClusterImpl(); void setCompression(CompressionType c) { compression = c; } CompressionType getCompression() const { return compression; } bool isCompressed() const { return compression == zimcompZip || compression == zimcompBzip2 || compression == zimcompLzma; } size_type getCount() const { return offsets.size() - 1; } const char* getData(unsigned n) const { return &data()[ offsets[n] ]; } size_type getSize(unsigned n) const { return offsets[n+1] - offsets[n]; } size_type getSize() const { return offsets.size() * sizeof(size_type) + data().size(); } offset_type getOffset(size_type n) const { return startOffset + offsets[n]; } Blob getBlob(size_type n) const; void clear(); void addBlob(const Blob& blob); void addBlob(const char* data, unsigned size); void init_from_stream(ifstream& in, offset_type offset); }; class Cluster { friend std::ostream& operator<< (std::ostream& out, const Cluster& blob); SmartPtr impl; ClusterImpl* getImpl(); public: Cluster(); void setCompression(CompressionType c) { getImpl()->setCompression(c); } CompressionType getCompression() const { return impl ? impl->getCompression() : zimcompNone; } bool isCompressed() const { return impl && (impl->getCompression() == zimcompZip || impl->getCompression() == zimcompBzip2 || impl->getCompression() == zimcompLzma); } const char* getBlobPtr(size_type n) const { return impl->getData(n); } size_type getBlobSize(size_type n) const { return impl->getSize(n); } offset_type getBlobOffset(size_type n) const { return impl->getOffset(n); } Blob getBlob(size_type n) const; size_type count() const { return impl ? impl->getCount() : 0; } size_type size() const { return impl ? impl->getSize(): sizeof(size_type); } void clear() { if (impl) impl->clear(); } void addBlob(const char* data, unsigned size) { getImpl()->addBlob(data, size); } void addBlob(const Blob& blob) { getImpl()->addBlob(blob); } operator bool() const { return impl; } void init_from_stream(ifstream& in, offset_type offset); }; std::ostream& operator<< (std::ostream& out, const ClusterImpl& blobImpl); std::ostream& operator<< (std::ostream& out, const Cluster& blob); } #endif // ZIM_CLUSTER_H libzim-2.0.0/include/zim/dirent.h000066400000000000000000000104221312444564200166630ustar00rootroot00000000000000/* * Copyright (C) 2006 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_DIRENT_H #define ZIM_DIRENT_H #include #include namespace zim { class Dirent { uint16_t mimeType; size_type version; size_type clusterNumber; // only used when redirect is false size_type blobNumber; // only used when redirect is false size_type redirectIndex; // only used when redirect is true char ns; std::string title; std::string url; std::string parameter; public: // these constants are put into mimeType field static const uint16_t redirectMimeType = 0xffff; static const uint16_t linktargetMimeType = 0xfffe; static const uint16_t deletedMimeType = 0xfffd; Dirent() : mimeType(0), version(0), clusterNumber(0), blobNumber(0), redirectIndex(0), ns('\0') {} bool isRedirect() const { return mimeType == redirectMimeType; } bool isLinktarget() const { return mimeType == linktargetMimeType; } bool isDeleted() const { return mimeType == deletedMimeType; } bool isArticle() const { return !isRedirect() && !isLinktarget() && !isDeleted(); } uint16_t getMimeType() const { return mimeType; } size_type getVersion() const { return version; } void setVersion(size_type v) { version = v; } size_type getClusterNumber() const { return isRedirect() ? 0 : clusterNumber; } size_type getBlobNumber() const { return isRedirect() ? 0 : blobNumber; } void setCluster(size_type clusterNumber_, size_type blobNumber_) { clusterNumber = clusterNumber_; blobNumber = blobNumber_; } size_type getRedirectIndex() const { return isRedirect() ? redirectIndex : 0; } char getNamespace() const { return ns; } const std::string& getTitle() const { return title.empty() ? url : title; } const std::string& getUrl() const { return url; } std::string getLongUrl() const; const std::string& getParameter() const { return parameter; } unsigned getDirentSize() const { unsigned ret = (isRedirect() ? 12 : 16) + url.size() + parameter.size() + 2; if (title != url) ret += title.size(); return ret; } void setTitle(const std::string& title_) { title = title_; } void setUrl(char ns_, const std::string& url_) { ns = ns_; url = url_; } void setParameter(const std::string& parameter_) { parameter = parameter_; } void setRedirect(size_type idx) { redirectIndex = idx; mimeType = redirectMimeType; clusterNumber = 0; blobNumber = 0; } void setMimeType(uint16_t mime) { mimeType = mime; } void setLinktarget() { mimeType = linktargetMimeType; clusterNumber = 0; blobNumber = 0; } void setDeleted() { mimeType = deletedMimeType; clusterNumber = 0; blobNumber = 0; } void setArticle(uint16_t mimeType_, size_type clusterNumber_, size_type blobNumber_) { mimeType = mimeType_; clusterNumber = clusterNumber_; blobNumber = blobNumber_; } }; std::ostream& operator<< (std::ostream& out, const Dirent& fh); std::istream& operator>> (std::istream& in, Dirent& fh); } #endif // ZIM_DIRENT_H libzim-2.0.0/include/zim/error.h000066400000000000000000000021021312444564200165230ustar00rootroot00000000000000/* * Copyright (C) 2006 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_ERROR_H #define ZIM_ERROR_H #include namespace zim { class ZimFileFormatError : public std::runtime_error { public: explicit ZimFileFormatError(const std::string& msg) : std::runtime_error(msg) { } }; } #endif // ZIM_ERROR_H libzim-2.0.0/include/zim/file.h000066400000000000000000000077231312444564200163270ustar00rootroot00000000000000/* * Copyright (C) 2006,2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_FILE_H #define ZIM_FILE_H #include #include #include #include #include #include namespace zim { class Article; class Search; class File { SmartPtr impl; public: File() { } explicit File(const std::string& fname) : impl(new FileImpl(fname.c_str())) { } const std::string& getFilename() const { return impl->getFilename(); } const Fileheader& getFileheader() const { return impl->getFileheader(); } offset_type getFilesize() const { return impl->getFilesize(); } Dirent getDirent(size_type idx) const { return impl->getDirent(idx); } Dirent getDirentByTitle(size_type idx) const { return impl->getDirentByTitle(idx); } size_type getCountArticles() const { return impl->getCountArticles(); } Article getArticle(size_type idx) const; Article getArticle(char ns, const std::string& url) const; Article getArticleByUrl(const std::string& url) const; Article getArticleByTitle(size_type idx) const; Article getArticleByTitle(char ns, const std::string& title) const; Cluster getCluster(size_type idx) const { return impl->getCluster(idx); } size_type getCountClusters() const { return impl->getCountClusters(); } offset_type getClusterOffset(size_type idx) const { return impl->getClusterOffset(idx); } Blob getBlob(size_type clusterIdx, size_type blobIdx) const { return getCluster(clusterIdx).getBlob(blobIdx); } offset_type getOffset(size_type clusterIdx, size_type blobIdx) const; size_type getNamespaceBeginOffset(char ch) const { return impl->getNamespaceBeginOffset(ch); } size_type getNamespaceEndOffset(char ch) const { return impl->getNamespaceEndOffset(ch); } size_type getNamespaceCount(char ns) const { return getNamespaceEndOffset(ns) - getNamespaceBeginOffset(ns); } std::string getNamespaces() const { return impl->getNamespaces(); } bool hasNamespace(char ch) const; class const_iterator; const_iterator begin() const; const_iterator beginByTitle() const; const_iterator end() const; std::pair findx(char ns, const std::string& url) const; std::pair findx(const std::string& url) const; std::pair findxByTitle(char ns, const std::string& title) const; const_iterator findByTitle(char ns, const std::string& title) const; const_iterator find(char ns, const std::string& url) const; const_iterator find(const std::string& url) const; const Search* search(const std::string& query, int start, int end) const; bool good() const { return impl.getPointer() != 0; } time_t getMTime() const { return impl->getMTime(); } const std::string& getMimeType(uint16_t idx) const { return impl->getMimeType(idx); } std::string getChecksum() { return impl->getChecksum(); } bool verify() { return impl->verify(); } }; std::string urldecode(const std::string& url); } #endif // ZIM_FILE_H libzim-2.0.0/include/zim/fileheader.h000066400000000000000000000073161312444564200174760ustar00rootroot00000000000000/* * Copyright (C) 2008 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_FILEHEADER_H #define ZIM_FILEHEADER_H #include #include #include #include #ifdef _WIN32 #define NOMINMAX #include #undef NOMINMAX #undef max #endif namespace zim { class Fileheader { public: static const size_type zimMagic; static const size_type zimVersion; static const size_type size; private: Uuid uuid; size_type articleCount; offset_type titleIdxPos; offset_type urlPtrPos; offset_type mimeListPos; size_type blobCount; offset_type blobPtrPos; size_type mainPage; size_type layoutPage; offset_type checksumPos; public: Fileheader() : articleCount(0), titleIdxPos(0), urlPtrPos(0), blobCount(0), blobPtrPos(0), mainPage(std::numeric_limits::max()), layoutPage(std::numeric_limits::max()), checksumPos(std::numeric_limits::max()) {} const Uuid& getUuid() const { return uuid; } void setUuid(const Uuid& uuid_) { uuid = uuid_; } size_type getArticleCount() const { return articleCount; } void setArticleCount(size_type s) { articleCount = s; } offset_type getTitleIdxPos() const { return titleIdxPos; } void setTitleIdxPos(offset_type p) { titleIdxPos = p; } offset_type getUrlPtrPos() const { return urlPtrPos; } void setUrlPtrPos(offset_type p) { urlPtrPos = p; } offset_type getMimeListPos() const { return mimeListPos; } void setMimeListPos(offset_type p) { mimeListPos = p; } size_type getClusterCount() const { return blobCount; } void setClusterCount(size_type s) { blobCount = s; } offset_type getClusterPtrPos() const { return blobPtrPos; } void setClusterPtrPos(offset_type p) { blobPtrPos = p; } bool hasMainPage() const { return mainPage != std::numeric_limits::max(); } size_type getMainPage() const { return mainPage; } void setMainPage(size_type s) { mainPage = s; } bool hasLayoutPage() const { return layoutPage != std::numeric_limits::max(); } size_type getLayoutPage() const { return layoutPage; } void setLayoutPage(size_type s) { layoutPage = s; } bool hasChecksum() const { return getMimeListPos() >= 80; } offset_type getChecksumPos() const { return hasChecksum() ? checksumPos : 0; } void setChecksumPos(offset_type p) { checksumPos = p; } }; std::ostream& operator<< (std::ostream& out, const Fileheader& fh); std::istream& operator>> (std::istream& in, Fileheader& fh); } #endif // ZIM_FILEHEADER_H libzim-2.0.0/include/zim/fileimpl.h000066400000000000000000000054721312444564200172100ustar00rootroot00000000000000/* * Copyright (C) 2006 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_FILEIMPL_H #define ZIM_FILEIMPL_H #include #include #include #include #include #include #include #include #include #include namespace zim { class FileImpl : public RefCounted { ifstream zimFile; Fileheader header; std::string filename; Cache direntCache; Cache clusterCache; bool cacheUncompressedCluster; typedef std::map NamespaceCache; NamespaceCache namespaceBeginCache; NamespaceCache namespaceEndCache; std::string namespaces; typedef std::vector MimeTypes; MimeTypes mimeTypes; offset_type getOffset(offset_type ptrOffset, size_type idx); public: explicit FileImpl(const char* fname); time_t getMTime() const { return zimFile.getMTime(); } const std::string& getFilename() const { return filename; } const Fileheader& getFileheader() const { return header; } offset_type getFilesize() const { return zimFile.fsize(); } Dirent getDirent(size_type idx); Dirent getDirentByTitle(size_type idx); size_type getIndexByTitle(size_type idx); size_type getCountArticles() const { return header.getArticleCount(); } Cluster getCluster(size_type idx); size_type getCountClusters() const { return header.getClusterCount(); } offset_type getClusterOffset(size_type idx) { return getOffset(header.getClusterPtrPos(), idx); } size_type getNamespaceBeginOffset(char ch); size_type getNamespaceEndOffset(char ch); size_type getNamespaceCount(char ns) { return getNamespaceEndOffset(ns) - getNamespaceBeginOffset(ns); } std::string getNamespaces(); bool hasNamespace(char ch); const std::string& getMimeType(uint16_t idx) const; std::string getChecksum(); bool verify(); }; } #endif // ZIM_FILEIMPL_H libzim-2.0.0/include/zim/fileiterator.h000066400000000000000000000052261312444564200200750ustar00rootroot00000000000000/* * Copyright (C) 2006 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_FILEITERATOR_H #define ZIM_FILEITERATOR_H #include #include namespace zim { class File::const_iterator : public std::iterator { public: enum Mode { UrlIterator, ArticleIterator }; private: const File* file; size_type idx; mutable Article article; Mode mode; bool is_end() const { return file == 0 || idx >= file->getCountArticles(); } public: explicit const_iterator(const File* file_ = 0, size_type idx_ = 0, Mode mode_ = UrlIterator) : file(file_), idx(idx_), mode(mode_) { } size_type getIndex() const { return idx; } const File& getFile() const { return *file; } bool operator== (const const_iterator& it) const { return (is_end() && it.is_end()) || (file == it.file && idx == it.idx); } bool operator!= (const const_iterator& it) const { return !operator==(it); } const_iterator& operator++() { ++idx; article = Article(); return *this; } const_iterator operator++(int) { const_iterator it = *this; operator++(); return it; } const_iterator& operator--() { --idx; article = Article(); return *this; } const_iterator operator--(int) { const_iterator it = *this; operator--(); return it; } const Article& operator*() const { if (!article.good()) article = mode == UrlIterator ? file->getArticle(idx) : file->getArticleByTitle(idx); return article; } pointer operator->() const { operator*(); return &article; } }; } #endif // ZIM_FILEITERATOR_H libzim-2.0.0/include/zim/fstream.h000066400000000000000000000055711312444564200170500ustar00rootroot00000000000000/* * Copyright (C) 2010 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_FSTREAM_H #define ZIM_FSTREAM_H #include #include #include #include #include #include namespace zim { class streambuf : public std::streambuf { struct FileInfo : public RefCounted { std::string fname; zim::offset_type fsize; FileInfo() { } FileInfo(const std::string& fname_, int fd); }; struct OpenfileInfo : public RefCounted { std::string fname; int fd; explicit OpenfileInfo(const std::string& fname); ~OpenfileInfo(); }; typedef SmartPtr FileInfoPtr; typedef std::vector FilesType; typedef SmartPtr OpenfileInfoPtr; typedef Cache OpenFilesCacheType; std::vector buffer; FilesType files; OpenFilesCacheType openFilesCache; OpenfileInfoPtr currentFile; std::streambuf::int_type overflow(std::streambuf::int_type ch); std::streambuf::int_type underflow(); int sync(); void setCurrentFile(const std::string& fname, zim::offset_type off); mutable time_t mtime; public: streambuf(const std::string& fname, unsigned bufsize, unsigned openFilesCache); void seekg(zim::offset_type off); void setBufsize(unsigned s) { buffer.resize(s); setg(0, 0, 0);} zim::offset_type fsize() const; time_t getMTime() const; }; class ifstream : public std::istream { streambuf myStreambuf; public: explicit ifstream(const std::string& fname, unsigned bufsize = 8192, unsigned openFilesCache = 5) : std::istream(0), myStreambuf(fname, bufsize, openFilesCache) { init(&myStreambuf); } void seekg(zim::offset_type off) { myStreambuf.seekg(off); } void setBufsize(unsigned s) { myStreambuf.setBufsize(s); } zim::offset_type fsize() const { return myStreambuf.fsize(); } time_t getMTime() const { return myStreambuf.getMTime(); } }; } #endif // ZIM_FSTREAM_H libzim-2.0.0/include/zim/noncopyable.h000066400000000000000000000032111312444564200177050ustar00rootroot00000000000000/* * Copyright (C) 2006 Tommi Maekitalo * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * As a special exception, you may use this file as part of a free * software library without restriction. Specifically, if other files * instantiate templates or use macros or inline functions from this * file, or you compile this file and link it with other files to * produce an executable, this file does not by itself cause the * resulting executable to be covered by the GNU General Public * License. This exception does not however invalidate any other * reasons why the executable file might be covered by the GNU Library * General Public License. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef ZIM_NONCOPYABLE_H #define ZIM_NONCOPYABLE_H namespace zim { class NonCopyable { private: NonCopyable(const NonCopyable&); // no implementation NonCopyable& operator=(const NonCopyable&); // no implementation public: NonCopyable() { } }; } #endif // ZIM_NONCOPYABLE_H libzim-2.0.0/include/zim/refcounted.h000066400000000000000000000035411312444564200175400ustar00rootroot00000000000000/* * Copyright (C) 2005 Tommi Maekitalo * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * As a special exception, you may use this file as part of a free * software library without restriction. Specifically, if other files * instantiate templates or use macros or inline functions from this * file, or you compile this file and link it with other files to * produce an executable, this file does not by itself cause the * resulting executable to be covered by the GNU General Public * License. This exception does not however invalidate any other * reasons why the executable file might be covered by the GNU Library * General Public License. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef ZIM_REFCOUNTED_H #define ZIM_REFCOUNTED_H #include namespace zim { class RefCounted : private NonCopyable { unsigned rc; public: RefCounted() : rc(0) { } explicit RefCounted(unsigned refs_) : rc(refs_) { } virtual ~RefCounted() { } virtual unsigned addRef() { return ++rc; } virtual void release() { if (--rc == 0) delete this; } unsigned refs() const { return rc; } }; } #endif // ZIM_REFCOUNTED_H libzim-2.0.0/include/zim/search.h000066400000000000000000000040601312444564200166440ustar00rootroot00000000000000/* * Copyright (C) 2007 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_SEARCH_H #define ZIM_SEARCH_H #include "search_iterator.h" #include #include #include namespace zim { class File; class Search { friend class search_iterator; friend class search_iterator::InternalData; public: typedef search_iterator iterator; explicit Search(const std::vector zimfiles); explicit Search(const File* zimfile); Search(const Search& it); Search& operator=(const Search& it); Search(Search&& it); Search& operator=(Search&& it); ~Search(); Search& add_zimfile(const File* zimfile); Search& set_query(const std::string& query); Search& set_range(int start, int end); search_iterator begin() const; search_iterator end() const; int get_matches_estimated() const; private: class InternalData; std::unique_ptr internal; std::vector zimfiles; mutable std::map valuesmap; std::string query; int range_start; int range_end; mutable bool search_started; mutable bool has_database; mutable int estimated_matches_number; }; } //namespace zim #endif // ZIM_SEARCH_H libzim-2.0.0/include/zim/search_iterator.h000066400000000000000000000041421312444564200205560ustar00rootroot00000000000000/* * Copyright (C) 2006 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_SEARCH_ITERATOR_H #define ZIM_SEARCH_ITERATOR_H #include #include #include "article.h" namespace zim { class search_iterator : public std::iterator { friend class zim::Search; public: search_iterator(); search_iterator(const search_iterator& it); search_iterator& operator=(const search_iterator& it); search_iterator(search_iterator&& it); search_iterator& operator=(search_iterator&& it); ~search_iterator(); bool operator== (const search_iterator& it) const; bool operator!= (const search_iterator& it) const; search_iterator& operator++(); search_iterator operator++(int); search_iterator& operator--(); search_iterator operator--(int); std::string get_url() const; std::string get_title() const; int get_score() const; std::string get_snippet() const; int get_wordCount() const; int get_size() const; reference operator*() const; pointer operator->() const; private: class InternalData; std::unique_ptr internal; search_iterator(InternalData* internal_data); bool is_end() const; }; } // namespace ziç #endif // ZIM_SEARCH_ITERATOR_H libzim-2.0.0/include/zim/smartptr.h000066400000000000000000000056561312444564200172670ustar00rootroot00000000000000/* * Copyright (C) 2005 Tommi Maekitalo * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * As a special exception, you may use this file as part of a free * software library without restriction. Specifically, if other files * instantiate templates or use macros or inline functions from this * file, or you compile this file and link it with other files to * produce an executable, this file does not by itself cause the * resulting executable to be covered by the GNU General Public * License. This exception does not however invalidate any other * reasons why the executable file might be covered by the GNU Library * General Public License. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef ZIM_SMARTPTR_H #define ZIM_SMARTPTR_H namespace zim { template class SmartPtr { objectType* object; public: SmartPtr() : object(0) {} SmartPtr(objectType* ptr) : object(ptr) { if (object) object->addRef(); } SmartPtr(const SmartPtr& ptr) : object(ptr.object) { if (object) object->addRef(); } ~SmartPtr() { if (object) object->release(); } SmartPtr& operator= (const SmartPtr& ptr) { if (object != ptr.object) { if (object) object->release(); object = ptr.object; if (object) object->addRef(); } return *this; } /// The object can be dereferenced like the held object objectType* operator->() const { return object; } /// The object can be dereferenced like the held object objectType& operator*() const { return *object; } bool operator== (const objectType* p) const { return object == p; } bool operator!= (const objectType* p) const { return object != p; } bool operator< (const objectType* p) const { return object < p; } bool operator! () const { return object == 0; } operator bool () const { return object != 0; } objectType* getPointer() { return object; } const objectType* getPointer() const { return object; } operator objectType* () { return object; } operator const objectType* () const { return object; } }; } #endif // ZIM_SMARTPTR_H libzim-2.0.0/include/zim/template.h000066400000000000000000000042111312444564200172100ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_TEMPLATE_H #define ZIM_TEMPLATE_H #include namespace zim { class TemplateParser { public: class Event { public: virtual void onData(const std::string& data) = 0; virtual void onToken(const std::string& token) = 0; virtual void onLink(char ns, const std::string& url) = 0; virtual ~Event() = default; }; private: Event* event; std::string data; std::string::size_type save; std::string::size_type token; std::string::size_type token_e; char ns; typedef void (TemplateParser::*state_type)(char); state_type state; void state_data(char ch); void state_lt(char ch); void state_token0(char ch); void state_token(char ch); void state_token_end(char ch); void state_link0(char ch); void state_link(char ch); void state_title(char ch); void state_title_end(char ch); public: explicit TemplateParser(Event* ev) : event(ev), state(&TemplateParser::state_data) { } void parse(char ch) { (this->*state)(ch); } void parse(const std::string& s) { for (std::string::const_iterator ch = s.begin(); ch != s.end(); ++ch) parse(*ch); } void flush(); }; } #endif // ZIM_TEMPLATE_H libzim-2.0.0/include/zim/uuid.h000066400000000000000000000026451312444564200163540ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_UUID_H #define ZIM_UUID_H #include #include #include namespace zim { struct Uuid { Uuid() { std::memset(data, 0, 16); } Uuid(const char uuid[16]) { std::copy(uuid, uuid+16, data); } static Uuid generate(); bool operator== (const Uuid& other) const { return std::equal(data, data+16, other.data); } bool operator!= (const Uuid& other) const { return !(*this == other); } unsigned size() const { return 16; } char data[16]; }; std::ostream& operator<< (std::ostream& out, const Uuid& uuid); } #endif // ZIM_UUID_H libzim-2.0.0/include/zim/writer/000077500000000000000000000000001312444564200165425ustar00rootroot00000000000000libzim-2.0.0/include/zim/writer/articlesource.h000066400000000000000000000053321312444564200215620ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_WRITER_ARTICLESOURCE_H #define ZIM_WRITER_ARTICLESOURCE_H #include #include #include #include #include namespace zim { namespace writer { class ArticleSource; class Article { public: virtual std::string getAid() const = 0; virtual char getNamespace() const = 0; virtual std::string getUrl() const = 0; virtual std::string getTitle() const = 0; virtual size_type getVersion() const; virtual bool isRedirect() const; virtual bool isLinktarget() const; virtual bool isDeleted() const; virtual std::string getMimeType() const = 0; virtual bool shouldCompress() const; virtual std::string getRedirectAid() const; virtual std::string getParameter() const; virtual Blob getData() const = 0; virtual ~Article() = default; // returns the next category id, to which the article is assigned to virtual std::string getNextCategory(); }; class Category { public: virtual Blob getData() = 0; virtual std::string getUrl() const = 0; virtual std::string getTitle() const = 0; virtual ~Category() = default; }; class ArticleSource { public: virtual void setFilename(const std::string& fname) { } virtual const Article* getNextArticle() = 0; virtual Uuid getUuid(); virtual std::string getMainPage(); virtual std::string getLayoutPage(); // After fetching the articles and for each article the category ids // using Article::getNextCategory, the writer has a list of category // ids. Using this list, the writer fetches the category data using // this method. virtual Category* getCategory(const std::string& cid); virtual ~ArticleSource() = default; }; } } #endif // ZIM_WRITER_ARTICLESOURCE_H libzim-2.0.0/include/zim/writer/dirent.h000066400000000000000000000042111312444564200201760ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_WRITER_DIRENT_H #define ZIM_WRITER_DIRENT_H #include namespace zim { namespace writer { class Dirent : public zim::Dirent { std::string aid; std::string redirectAid; size_type idx; bool compress; public: Dirent() {} Dirent(const std::string& aid_) : aid(aid_) {} Dirent(char ns, const std::string& url) { setUrl(ns, url); } void setAid(const std::string& aid_) { aid = aid_; } const std::string& getAid() const { return aid; } void setRedirectAid(const std::string& aid_) { redirectAid = aid_; } const std::string& getRedirectAid() const { return redirectAid; } void setIdx(size_type idx_) { idx = idx_; } size_type getIdx() const { return idx; } void setCompress(bool sw = true) { compress = sw; } bool isCompress() const { return compress; } }; inline bool compareUrl(const Dirent& d1, const Dirent& d2) { return d1.getNamespace() < d2.getNamespace() || (d1.getNamespace() == d2.getNamespace() && d1.getUrl() < d2.getUrl()); } inline bool compareAid(const Dirent& d1, const Dirent& d2) { return d1.getAid() < d2.getAid(); } } } #endif // ZIM_WRITER_DIRENT_H libzim-2.0.0/include/zim/writer/zimcreator.h000066400000000000000000000072101312444564200210720ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_WRITER_ZIMCREATOR_H #define ZIM_WRITER_ZIMCREATOR_H #include #include #include #include namespace zim { namespace writer { class ZimCreator { public: typedef std::vector DirentsType; typedef std::vector DirentPtrsType; typedef std::vector SizeVectorType; typedef std::vector OffsetsType; typedef std::map MimeTypes; typedef std::map RMimeTypes; private: unsigned minChunkSize; Fileheader header; DirentsType dirents; SizeVectorType titleIdx; OffsetsType clusterOffsets; MimeTypes mimeTypes; RMimeTypes rmimeTypes; uint16_t nextMimeIdx; CompressionType compression; bool isEmpty; offset_type clustersSize; offset_type currentSize; void createDirentsAndClusters(ArticleSource& src, const std::string& tmpfname); void createTitleIndex(ArticleSource& src); void fillHeader(ArticleSource& src); void write(const std::string& fname, const std::string& tmpfname); size_type clusterCount() const { return clusterOffsets.size(); } size_type articleCount() const { return dirents.size(); } offset_type mimeListSize() const; offset_type mimeListPos() const { return Fileheader::size; } offset_type urlPtrSize() const { return articleCount() * sizeof(offset_type); } offset_type urlPtrPos() const { return mimeListPos() + mimeListSize(); } offset_type titleIdxSize() const { return articleCount() * sizeof(size_type); } offset_type titleIdxPos() const { return urlPtrPos() + urlPtrSize(); } offset_type indexSize() const; offset_type indexPos() const { return titleIdxPos() + titleIdxSize(); } offset_type clusterPtrSize() const { return clusterCount() * sizeof(offset_type); } offset_type clusterPtrPos() const { return indexPos() + indexSize(); } offset_type checksumPos() const { return clusterPtrPos() + clusterPtrSize() + clustersSize; } uint16_t getMimeTypeIdx(const std::string& mimeType); const std::string& getMimeType(uint16_t mimeTypeIdx) const; public: ZimCreator(); ZimCreator(int& argc, char* argv[]); unsigned getMinChunkSize() { return minChunkSize; } void setMinChunkSize(int s) { minChunkSize = s; } void create(const std::string& fname, ArticleSource& src); /* The user can query `currentSize` after each article has been * added to the ZIM file. */ offset_type getCurrentSize() { return currentSize; } }; } } #endif // ZIM_WRITER_ZIMCREATOR_H libzim-2.0.0/include/zim/zim.h000066400000000000000000000046271312444564200162070ustar00rootroot00000000000000/* * Copyright (C) 2006 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_ZIM_H #define ZIM_ZIM_H #include namespace zim { // define 8 bit integer types // typedef unsigned char uint8_t; typedef char int8_t; // define 16 bit integer types // #if USHRT_MAX == 0xffff typedef unsigned short uint16_t; typedef short int16_t; #elif UINT_MAX == 0xffff typedef unsigned int uint16_t; typedef int int16_t; #elif ULONG_MAX == 0xffff typedef unsigned long uint16_t; typedef long int16_t; #else } #include namespace zim { #endif // define 32 bit integer types // #if USHRT_MAX == 0xffffffffUL typedef unsigned short uint32_t; typedef short int32_t; #elif UINT_MAX == 0xffffffffUL typedef unsigned int uint32_t; typedef int int32_t; #elif ULONG_MAX == 0xffffffffUL typedef unsigned long uint32_t; typedef long int32_t; #else } #include namespace zim { #endif // define 64 bit integer types // #if UINT_MAX == 18446744073709551615ULL typedef unsigned int uint64_t; typedef int int64_t; #elif ULONG_MAX == 18446744073709551615ULL typedef unsigned long uint64_t; typedef long int64_t; #elif ULLONG_MAX == 18446744073709551615ULL typedef unsigned long long uint64_t; typedef long long int64_t; #else } #include namespace zim { #endif typedef uint32_t size_type; #ifdef _WIN32 typedef __int64 offset_type; #else typedef uint64_t offset_type; #endif enum CompressionType { zimcompDefault, zimcompNone, zimcompZip, zimcompBzip2, // Not supported anymore in the libzim zimcompLzma }; static const char MimeHtmlTemplate[] = "text/x-zim-htmltemplate"; } #endif // ZIM_ZIM_H libzim-2.0.0/meson.build000066400000000000000000000025721312444564200151540ustar00rootroot00000000000000project('libzim', ['c', 'cpp'], version : '2.0.0', license : 'GPL2', default_options : ['c_std=c11', 'cpp_std=c++11']) conf = configuration_data() conf.set('VERSION', '"@0@"'.format(meson.project_version())) conf.set('DIRENT_CACHE_SIZE', get_option('DIRENT_CACHE_SIZE')) conf.set('CLUSTER_CACHE_SIZE', get_option('CLUSTER_CACHE_SIZE')) conf.set('LZMA_MEMORY_SIZE', get_option('LZMA_MEMORY_SIZE')) zlib_dep = dependency('zlib', required:false) conf.set('ENABLE_ZLIB', zlib_dep.found()) lzma_dep = dependency('liblzma', required:false) conf.set('ENABLE_LZMA', lzma_dep.found()) xapian_dep = dependency('xapian-core', required:false) conf.set('ENABLE_XAPIAN', xapian_dep.found()) pkg_requires = [] if zlib_dep.found() pkg_requires += ['zlib'] endif if lzma_dep.found() pkg_requires += ['liblzma'] endif if xapian_dep.found() pkg_requires += ['xapian-core'] icu_dep = dependency('icu-i18n') pkg_requires += ['icu-i18n'] else icu_dep = dependency('icu-i18n', required:false) endif inc = include_directories('include') subdir('include') subdir('src') subdir('examples') subdir('test') pkg_mod = import('pkgconfig') pkg_mod.generate(libraries : libzim, version : meson.project_version(), name : 'libzim', filebase : 'libzim', description : 'A Library to zim.', requires : pkg_requires) libzim-2.0.0/meson_options.txt000066400000000000000000000005661312444564200164500ustar00rootroot00000000000000option('CLUSTER_CACHE_SIZE', type : 'string', value : '16', description : 'set cluster cache size to number (default:16)') option('DIRENT_CACHE_SIZE', type : 'string', value : '512', description : 'set dirent cache size to number (default:512)') option('LZMA_MEMORY_SIZE', type : 'string', value : '128', description : 'set lzma uncompress memory in MB (default:128)')libzim-2.0.0/src/000077500000000000000000000000001312444564200135735ustar00rootroot00000000000000libzim-2.0.0/src/arg.h000066400000000000000000000314731312444564200145250ustar00rootroot00000000000000/* * Copyright (C) 2003,2004,2010 Tommi Maekitalo * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * As a special exception, you may use this file as part of a free * software library without restriction. Specifically, if other files * instantiate templates or use macros or inline functions from this * file, or you compile this file and link it with other files to * produce an executable, this file does not by itself cause the * resulting executable to be covered by the GNU General Public * License. This exception does not however invalidate any other * reasons why the executable file might be covered by the GNU Library * General Public License. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef ZIM_ARG_H #define ZIM_ARG_H #include #include namespace zim { class ArgBase { protected: bool m_isset; static void removeArg(int& argc, char* argv[], int pos, int n) { for ( ; pos < argc - n; ++pos) argv[pos] = argv[pos + n]; argc -= n; argv[argc] = 0; } public: ArgBase() : m_isset(false) { } /** * returns true if the option was found and the default value was not used */ bool isSet() const { return m_isset; } }; template class ArgBaseT : public ArgBase { T m_value; protected: explicit ArgBaseT(const T& def) : m_value(def) { } bool extract(const char* str, int& argc, char* argv[], int i, int n) { std::istringstream s(str); s >> m_value; if (!s.fail()) { m_isset = true; removeArg(argc, argv, i, n); return true; } return false; } public: /** returns the value. */ const T& getValue() const { return m_value; } /** @brief Read and extract commandline parameters from argc/argv. Programs usually need some parameters. Usually they start with a '-' followed by a single character and optionally a value. Arg extracts these and other parameters. This default class processes paramters with a value, which defines a input-extractor-operator operator>> (istream&, T&). Options are removed from the option-list, so programs can easily check after all options are extracted, if there are parameters left. example: \code int main(int argc, char* argv[]) { zim::Arg option_n(argc, argv, 'n', 0); std::cout << "value for -n: " << option_n << endl; } \endcode */ operator T() const { return m_value; } }; template <> class ArgBaseT : public ArgBase { const char* m_value; protected: explicit ArgBaseT(const char* def) : m_value(def) { } bool extract(const char* str, int& argc, char* argv[], int i, int n) { m_value = str; m_isset = true; removeArg(argc, argv, i, n); return true; } public: /// returns the extracted value. const char* getValue() const { return m_value; } /// class is convertible to "const char*" operator const char*() const { return m_value; } }; template <> class ArgBaseT : public ArgBase { std::string m_value; protected: explicit ArgBaseT(const std::string& def) : m_value(def) { } bool extract(const char* str, int& argc, char* argv[], int i, int n) { m_value = str; m_isset = true; removeArg(argc, argv, i, n); return true; } public: /// returns the extracted value. const std::string& getValue() const { return m_value; } /// class is convertible to "const std::string&" operator const std::string&() const { return m_value; } }; /** @brief Read and extract commandline parameters from argc/argv. Programs usually need some parameters. Usually they start with a '-' followed by a single character and optionally a value. Arg extracts these and other parameters. This default class processes paramters with a value, which defines a input-extractor-operator operator>> (istream&, T&). Options are removed from the option-list, so programs can easily check after all options are extracted, if there are parameters left. example: \code int main(int argc, char* argv[]) { zim::Arg option_n(argc, argv, 'n', 0); std::cout << "value for -n: " << option_n << endl; } \endcode */ template class Arg : public ArgBaseT { public: /** default constructor. Initializes value. \param def initial value */ Arg(const T& def = T()) : ArgBaseT(def) { } /** extract parameter. \param argc 1. parameter of main \param argv 2. of main \param ch optioncharacter \param def default-value example: \code zim::Arg offset(argc, argv, 'o', 0); unsigned value = offset.getValue(); \endcode */ Arg(int& argc, char* argv[], char ch, const T& def = T()) : ArgBaseT(def) { set(argc, argv, ch); } /** GNU defines long options starting with "--". This (and more) is supported here. Instead of giving a single option-character, you specify a string. example: \code zim::Arg option_number(argc, argv, "--number", 0); std::cout << "number =" << option_number.getValue() << std::endl; \endcode */ Arg(int& argc, char* argv[], const char* str, const T& def = T()) : ArgBaseT(def) { this->m_isset = set(argc, argv, str); } Arg(int& argc, char* argv[]) : ArgBaseT(T()) { this->m_isset = set(argc, argv); } /** extract parameter. \param argc 1. parameter of main \param argv 2. of main \param ch optioncharacter example: \code zim::Arg offset; offset.set(argc, argv, 'o'); unsigned value = offset.getValue(); \endcode */ bool set(int& argc, char* argv[], char ch) { // don't extract value, when already found if (this->m_isset) return false; for (int i = 1; i < argc; ++i) { if (argv[i][0] == '-' && argv[i][1] == ch) { if (argv[i][2] == '\0' && i < argc - 1) { // -O foo if (this->extract(argv[i + 1], argc, argv, i, 2)) return true; } // -Ofoo if (this->extract(argv[i] + 2, argc, argv, i, 1)) return true; } } return false; } /** GNU defines long options starting with "--". This (and more) is supported here. Instead of giving a single option-character, you specify a string. example: \code zim::Arg option_number; number.set(argc, argv, "--number"); std::cout << "number =" << option_number.getValue() << std::endl; \endcode */ bool set(int& argc, char* argv[], const char* str) { // don't extract value, when already found if (this->m_isset) return false; unsigned n = strlen(str); for (int i = 1; i < argc; ++i) { if (strncmp(argv[i], str, n) == 0) { if (i < argc - 1 && argv[i][n] == '\0') { // --option value if (this->extract(argv[i + 1], argc, argv, i, 2)) return true; } if (argv[i][n] == '=') { // --option=vlaue if (this->extract(argv[i] + n + 1, argc, argv, i, 1)) return true; } } } return false; } /** Reads next parameter and removes it. */ bool set(int& argc, char* argv[]) { // don't extract value, when already found if (this->m_isset) return false; if (argc > 1) this->extract(argv[1], argc, argv, 1, 1); return this->m_isset; } }; //////////////////////////////////////////////////////////////////////// /** specialization for bool. Often programs need some switches, which are switched on or off. Users just enter a option without parameter. example: \code zim::Arg debug(argc, argv, 'd'); if (debug) std::cout << "debug-mode is set" << std::endl; \endcode */ template <> class Arg : public ArgBase { public: /** default constructor. Initializes value. \param def initial value */ Arg(bool def = false) : m_value(def) { } /** Use this constructor to extract a bool-parameter. As a special case options can be grouped. The parameter is recognized also in a argument, which starts with a '-' and contains somewhere the given character. example: \code zim::Arg debug(argc, argv, 'd'); zim::Arg ignore(argc, argv, 'i'); \endcode Arguments debug and ignore are both set when the program is called with: \code prog -id prog -i -d \endcode Options can also switched off with a following '-' like this: \code prog -d- \endcode In the program use: \code Arg debug(argc, argv, 'd'); if (debug.isSet()) { if (debug) std::cout << "you entered -d" << std::endl; else std::cout << "you entered -d-" << std::endl; } else std::cout << "no -d option given" << std::endl; \endcode This is useful, if a program defaults to some enabled feature, which can be disabled. */ Arg(int& argc, char* argv[], char ch, bool def = false) : m_value(def) { m_isset = set(argc, argv, ch); } Arg(int& argc, char* argv[], const char* str, bool def = false) : m_value(def) { m_isset = set(argc, argv, str); } bool set(int& argc, char* argv[], char ch) { // don't extract value, when already found if (m_isset) return false; for (int i = 1; i < argc; ++i) { if (argv[i][0] == '-' && argv[i][1] != '-') { // starts with a '-', but not with "--" if (argv[i][1] == ch && argv[i][2] == '\0') { // single option found m_value = true; m_isset = true; removeArg(argc, argv, i, 1); return true; } else if (argv[i][1] == ch && argv[i][2] == '-' && argv[i][3] == '\0') { // Option was explicitly disabled with -x- m_value = false; m_isset = true; removeArg(argc, argv, i, 1); return true; } else { // look, if we find the option in an optiongroup for (char* p = argv[i] + 1; *p != '\0'; ++p) if (*p == ch) { // here it is - extract it m_value = true; m_isset = true; do { *p = *(p + 1); } while (*p++ != '\0'); return true; } } } } return false; } /** Setter for long-options. The option-parameter is defined with a string. This can extract long-options like: \code prog --debug \endcode with \code Arg debug(argc, argv, "--debug"); \endcode */ bool set(int& argc, char* argv[], const char* str) { // don't extract value, when already found if (m_isset) return false; for (int i = 1; i < argc; ++i) { if (strcmp(argv[i], str) == 0) { m_value = true; m_isset = true; removeArg(argc, argv, i, 1); return true; } } return false; } /** returns true, if options is set. */ bool isTrue() const { return m_value; } /** returns true, if options is not set. */ bool isFalse() const { return !m_value; } /** convertable to bool. */ operator bool() const { return m_value; } private: bool m_value; }; template std::ostream& operator<< (std::ostream& out, const ArgBaseT arg) { return out << arg.getValue(); } } #endif // ZIM_ARG_H libzim-2.0.0/src/article.cpp000066400000000000000000000075101312444564200157250ustar00rootroot00000000000000/* * Copyright (C) 2006 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #include #include #include #include "log.h" log_define("zim.article") namespace zim { size_type Article::getArticleSize() const { Dirent dirent = getDirent(); return file.getCluster(dirent.getClusterNumber()) .getBlobSize(dirent.getBlobNumber()); } namespace { class Ev : public TemplateParser::Event { std::ostream& out; Article& article; unsigned maxRecurse; public: Ev(std::ostream& out_, Article& article_, unsigned maxRecurse_) : out(out_), article(article_), maxRecurse(maxRecurse_) { } void onData(const std::string& data); void onToken(const std::string& token); void onLink(char ns, const std::string& title); }; void Ev::onData(const std::string& data) { out << data; } void Ev::onToken(const std::string& token) { log_trace("onToken(\"" << token << "\")"); if (token == "title") out << article.getTitle(); else if (token == "url") out << article.getUrl(); else if (token == "namespace") out << article.getNamespace(); else if (token == "content") { if (maxRecurse <= 0) throw std::runtime_error("maximum recursive limit is reached"); article.getPage(out, false, maxRecurse - 1); } else { log_warn("unknown token \"" << token << "\" found in template"); out << "<%" << token << "%>"; } } void Ev::onLink(char ns, const std::string& url) { if (maxRecurse <= 0) throw std::runtime_error("maximum recursive limit is reached"); article.getFile().getArticle(ns, url).getPage(out, false, maxRecurse - 1); } } std::string Article::getPage(bool layout, unsigned maxRecurse) { std::ostringstream s; getPage(s, layout, maxRecurse); return s.str(); } void Article::getPage(std::ostream& out, bool layout, unsigned maxRecurse) { log_trace("Article::getPage(" << layout << ", " << maxRecurse << ')'); if (getMimeType().compare(0, 9, "text/html") == 0 || getMimeType() == MimeHtmlTemplate) { if (layout && file.getFileheader().hasLayoutPage()) { Article layoutPage = file.getArticle(file.getFileheader().getLayoutPage()); Blob data = layoutPage.getData(); Ev ev(out, *this, maxRecurse); log_debug("call template parser"); TemplateParser parser(&ev); for (const char* p = data.data(); p != data.end(); ++p) parser.parse(*p); parser.flush(); return; } else if (getMimeType() == MimeHtmlTemplate) { Blob data = getData(); Ev ev(out, *this, maxRecurse); TemplateParser parser(&ev); for (const char* p = data.data(); p != data.end(); ++p) parser.parse(*p); parser.flush(); return; } } // default case - template cases has return above out << getData(); } } libzim-2.0.0/src/articlesource.cpp000066400000000000000000000040521312444564200171440ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include namespace zim { namespace writer { size_type Article::getVersion() const { return 0; } bool Article::isRedirect() const { return false; } bool Article::isLinktarget() const { return false; } bool Article::isDeleted() const { return false; } bool Article::shouldCompress() const { std::string mimeType = getMimeType(); return mimeType != "image/jpeg" && mimeType != "image/png" && mimeType != "image/tiff" && mimeType != "image/gif" && mimeType != "application/zip"; } std::string Article::getRedirectAid() const { return std::string(); } std::string Article::getParameter() const { return std::string(); } std::string Article::getNextCategory() { return std::string(); } Uuid ArticleSource::getUuid() { return Uuid::generate(); } std::string ArticleSource::getMainPage() { return std::string(); } std::string ArticleSource::getLayoutPage() { return std::string(); } Category* ArticleSource::getCategory(const std::string& cid) { return 0; } } } libzim-2.0.0/src/cluster.cpp000066400000000000000000000203431312444564200157620ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #include "endian_tools.h" #include #include #include #include "log.h" #include "config.h" #if defined(ENABLE_ZLIB) #include "deflatestream.h" #include "inflatestream.h" #endif #if defined(ENABLE_LZMA) #include "lzmastream.h" #include "unlzmastream.h" #endif log_define("zim.cluster") #define log_debug1(e) namespace zim { Cluster::Cluster() : impl(0) { } ClusterImpl* Cluster::getImpl() { if (impl.getPointer() == 0) impl = new ClusterImpl(); return impl; } ClusterImpl::ClusterImpl() : compression(zimcompNone), startOffset(0), lazy_read_stream(NULL) { offsets.push_back(0); } /* This return the number of char read */ offset_type ClusterImpl::read_header(std::istream& in) { log_debug1("read_header"); // read first offset, which specifies, how many offsets we need to read size_type offset; in.read(reinterpret_cast(&offset), sizeof(offset)); if (in.fail()) { std::cerr << "fail at read offset" << std::endl; throw ZimFileFormatError("fail at read first offset"); } offset = fromLittleEndian(&offset); size_type n = offset / 4; size_type a = offset; log_debug1("first offset is " << offset << " n=" << n << " a=" << a); // read offsets offsets.clear(); offsets.reserve(n); offsets.push_back(0); while (--n) { in.read(reinterpret_cast(&offset), sizeof(offset)); if (in.fail()) { log_debug("fail at " << n); throw ZimFileFormatError("fail at read offset"); } offset = fromLittleEndian(&offset); log_debug1("offset=" << offset << '(' << offset-a << ')'); offsets.push_back(offset - a); } return a; } void ClusterImpl::read_content(std::istream& in) { log_debug1("read_content"); _data.clear(); // last offset points past the end of the cluster, so we know now, how may bytes to read if (offsets.size() > 1) { size_type n = offsets.back() - offsets.front(); if (n > 0) { _data.resize(n); log_debug("read " << n << " bytes of data"); in.read(&(_data[0]), n); } else log_warn("read empty cluster"); } } void ClusterImpl::finalise_read() { if ( !lazy_read_stream ) { std::cerr << "lazy_read null" << std::endl; return; } lazy_read_stream->seekg(startOffset); read_content(*lazy_read_stream); lazy_read_stream = NULL; } void ClusterImpl::write(std::ostream& out) const { size_type a = offsets.size() * sizeof(size_type); for (Offsets::const_iterator it = offsets.begin(); it != offsets.end(); ++it) { size_type o = *it; o += a; o = fromLittleEndian(&o); out.write(reinterpret_cast(&o), sizeof(size_type)); } if (_data.size() > 0) out.write(&(_data[0]), _data.size()); else log_warn("write empty cluster"); } void ClusterImpl::addBlob(const Blob& blob) { log_debug1("addBlob(ptr, " << blob.size() << ')'); _data.insert(_data.end(), blob.data(), blob.end()); offsets.push_back(_data.size()); } Blob ClusterImpl::getBlob(size_type n) const { size_type s = getSize(); return s > 0 ? Blob(const_cast(this), getData(n), getSize(n)) : Blob(); } void ClusterImpl::clear() { offsets.clear(); _data.clear(); offsets.push_back(0); } void ClusterImpl::addBlob(const char* data, unsigned size) { addBlob(Blob(data, size)); } Blob Cluster::getBlob(size_type n) const { return impl->getBlob(n); } void Cluster::init_from_stream(ifstream& in, offset_type offset) { getImpl()->init_from_stream(in, offset); } void ClusterImpl::init_from_stream(ifstream& in, offset_type offset) { log_trace("init_from_stream"); in.seekg(offset); clear(); char c; in.get(c); setCompression(static_cast(c)); switch (static_cast(c)) { case zimcompDefault: case zimcompNone: startOffset = read_header(in); startOffset += sizeof(char) + offset; set_lazy_read(&in); break; case zimcompZip: { #if defined(ENABLE_ZLIB) log_debug("uncompress data (zlib)"); zim::InflateStream is(in); is.exceptions(std::ios::failbit | std::ios::badbit); read_header(is); read_content(is); #else throw std::runtime_error("zlib not enabled in this library"); #endif break; } case zimcompBzip2: { throw std::runtime_error("bzip2 not enabled in this library"); break; } case zimcompLzma: { #if defined(ENABLE_LZMA) log_debug("uncompress data (lzma)"); zim::UnlzmaStream is(in); is.exceptions(std::ios::failbit | std::ios::badbit); read_header(is); read_content(is); #else throw std::runtime_error("lzma not enabled in this library"); #endif break; } default: log_error("invalid compression flag " << c); in.setstate(std::ios::failbit); break; } } std::ostream& operator<< (std::ostream& out, const ClusterImpl& clusterImpl) { log_trace("write cluster"); out.put(static_cast(clusterImpl.getCompression())); switch(clusterImpl.getCompression()) { case zimcompDefault: case zimcompNone: clusterImpl.write(out); break; case zimcompZip: { #if defined(ENABLE_ZLIB) log_debug("compress data (zlib)"); zim::DeflateStream os(out); os.exceptions(std::ios::failbit | std::ios::badbit); clusterImpl.write(os); os.flush(); #else throw std::runtime_error("zlib not enabled in this library"); #endif break; } case zimcompBzip2: { throw std::runtime_error("bzip2 not enabled in this library"); break; } case zimcompLzma: { #if defined(ENABLE_LZMA) uint32_t lzmaPreset = 3 | LZMA_PRESET_EXTREME; /** * read lzma preset from environment * ZIM_LZMA_PRESET is a number followed optionally by a * suffix 'e'. The number gives the preset and the suffix tells, * if LZMA_PRESET_EXTREME should be set. * e.g.: * ZIM_LZMA_LEVEL=9 => 9 * ZIM_LZMA_LEVEL=3e => 3 + extreme */ const char* e = ::getenv("ZIM_LZMA_LEVEL"); if (e) { char flag = '\0'; std::istringstream s(e); s >> lzmaPreset >> flag; if (flag == 'e') lzmaPreset |= LZMA_PRESET_EXTREME; } log_debug("compress data (lzma, " << std::hex << lzmaPreset << ")"); zim::LzmaStream os(out, lzmaPreset); os.exceptions(std::ios::failbit | std::ios::badbit); clusterImpl.write(os); os.end(); #else throw std::runtime_error("lzma not enabled in this library"); #endif break; } default: std::ostringstream msg; msg << "invalid compression flag " << clusterImpl.getCompression(); log_error(msg.str()); throw std::runtime_error(msg.str()); } return out; } std::ostream& operator<< (std::ostream& out, const Cluster& cluster) { return out << *cluster.impl; } } libzim-2.0.0/src/config.h.in000066400000000000000000000003061312444564200156150ustar00rootroot00000000000000 #mesondefine VERSION #mesondefine DIRENT_CACHE_SIZE #mesondefine CLUSTER_CACHE_SIZE #mesondefine LZMA_MEMORY_SIZE #mesondefine ENABLE_ZLIB #mesondefine ENABLE_LZMA #mesondefine ENABLE_XAPIAN libzim-2.0.0/src/deflatestream.cpp000066400000000000000000000113221312444564200171160ustar00rootroot00000000000000/* deflatestream.cpp * Copyright (C) 2003-2005 Tommi Maekitalo * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * */ #include "deflatestream.h" #include "log.h" #include #include log_define("zim.deflatestream") namespace zim { namespace { int checkError(int ret, z_stream& stream) { if (ret != Z_OK && ret != Z_STREAM_END) { log_error("DeflateError " << ret << ": \"" << (stream.msg ? stream.msg : "") << '"'); std::ostringstream msg; msg << "deflate-error " << ret; if (stream.msg) msg << ": " << stream.msg; throw DeflateError(ret, msg.str()); } return ret; } } DeflateStreamBuf::DeflateStreamBuf(std::streambuf* sink_, int level, unsigned bufsize_) : obuffer(bufsize_), sink(sink_) { memset(&stream, 0, sizeof(z_stream)); stream.zalloc = Z_NULL; stream.zfree = Z_NULL; stream.opaque = 0; stream.total_out = 0; stream.total_in = 0; stream.next_in = Z_NULL; stream.next_out = Z_NULL; stream.avail_in = 0; stream.avail_out = 0; checkError(::deflateInit(&stream, level), stream); setp(&obuffer[0], &obuffer[0] + obuffer.size()); } DeflateStreamBuf::~DeflateStreamBuf() { ::deflateEnd(&stream); } DeflateStreamBuf::int_type DeflateStreamBuf::overflow(int_type c) { // initialize input-stream stream.next_in = reinterpret_cast(&obuffer[0]); stream.avail_in = pptr() - &obuffer[0]; // initialize zbuffer for deflated data char zbuffer[8192]; stream.next_out = reinterpret_cast(zbuffer); stream.avail_out = sizeof(zbuffer); // deflate checkError(::deflate(&stream, Z_NO_FLUSH), stream); // copy zbuffer to sink / consume deflated data std::streamsize count = sizeof(zbuffer) - stream.avail_out; if (count > 0) { std::streamsize n = sink->sputn(zbuffer, count); if (n < count) return traits_type::eof(); } // move remaining characters to start of obuffer if (stream.avail_in > 0) memmove(&obuffer[0], stream.next_in, stream.avail_in); // reset outbuffer setp(&obuffer[0] + stream.avail_in, &obuffer[0] + obuffer.size()); if (c != traits_type::eof()) sputc(traits_type::to_char_type(c)); return 0; } DeflateStreamBuf::int_type DeflateStreamBuf::underflow() { return traits_type::eof(); } int DeflateStreamBuf::sync() { // initialize input-stream for stream.next_in = reinterpret_cast(&obuffer[0]); stream.avail_in = pptr() - &obuffer[0]; char zbuffer[8192]; while (stream.avail_in > 0) { // initialize zbuffer stream.next_out = (Bytef*)zbuffer; stream.avail_out = sizeof(zbuffer); checkError(::deflate(&stream, Z_SYNC_FLUSH), stream); // copy zbuffer to sink std::streamsize count = sizeof(zbuffer) - stream.avail_out; if (count > 0) { std::streamsize n = sink->sputn(zbuffer, count); if (n < count) return -1; } }; // reset outbuffer setp(&obuffer[0], &obuffer[0] + obuffer.size()); return 0; } int DeflateStreamBuf::end() { char zbuffer[8192]; // initialize input-stream for stream.next_in = reinterpret_cast(&obuffer[0]); stream.avail_in = pptr() - &obuffer[0]; while (true) { // initialize zbuffer stream.next_out = (Bytef*)zbuffer; stream.avail_out = sizeof(zbuffer); int ret = checkError(::deflate(&stream, Z_FINISH), stream); // copy zbuffer to sink std::streamsize count = sizeof(zbuffer) - stream.avail_out; if (count > 0) { std::streamsize n = sink->sputn(zbuffer, count); if (n < count) throw DeflateError(0, "failed to send compressed data to sink in deflatestream"); } if (ret == Z_STREAM_END) break; }; // reset outbuffer setp(&obuffer[0], &obuffer[0] + obuffer.size()); return 0; } void DeflateStream::end() { if (streambuf.end() != 0) setstate(failbit); } } libzim-2.0.0/src/deflatestream.h000066400000000000000000000050441312444564200165670ustar00rootroot00000000000000/* * Copyright (C) 2005-2008 Tommi Maekitalo * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_DEFLATESTREAM_H #define ZIM_DEFLATESTREAM_H #include #include #include #include namespace zim { class DeflateError : public std::runtime_error { int zRet; public: DeflateError(int zRet_, const std::string& msg) : std::runtime_error(msg), zRet(zRet_) { } int getRet() const { return zRet; } }; class DeflateStreamBuf : public std::streambuf { z_stream stream; std::vector obuffer; std::streambuf* sink; public: explicit DeflateStreamBuf(std::streambuf* sink_, int level = Z_DEFAULT_COMPRESSION, unsigned bufsize = 8192); ~DeflateStreamBuf(); /// see std::streambuf int_type overflow(int_type c); /// see std::streambuf int_type underflow(); /// see std::streambuf int sync(); /// end deflate-stream int end(); void setSink(std::streambuf* sink_) { sink = sink_; } uLong getAdler() const { return stream.adler; } }; class DeflateStream : public std::ostream { DeflateStreamBuf streambuf; public: explicit DeflateStream(std::streambuf* sink, int level = Z_DEFAULT_COMPRESSION) : std::ostream(0), streambuf(sink, level) { init(&streambuf); } explicit DeflateStream(std::ostream& sink, int level = Z_DEFAULT_COMPRESSION) : std::ostream(0), streambuf(sink.rdbuf(), level) { init(&streambuf); } void end(); void setSink(std::streambuf* sink) { streambuf.setSink(sink); } void setSink(std::ostream& sink) { streambuf.setSink(sink.rdbuf()); } uLong getAdler() const { return streambuf.getAdler(); } }; } #endif // ZIM_DEFLATESTREAM_H libzim-2.0.0/src/dirent.cpp000066400000000000000000000116211312444564200155650ustar00rootroot00000000000000/* * Copyright (C) 2006 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #include "endian_tools.h" #include "log.h" #include log_define("zim.dirent") namespace zim { ////////////////////////////////////////////////////////////////////// // Dirent // const uint16_t Dirent::redirectMimeType; const uint16_t Dirent::linktargetMimeType; const uint16_t Dirent::deletedMimeType; std::ostream& operator<< (std::ostream& out, const Dirent& dirent) { union { char d[16]; long a; } header; toLittleEndian(dirent.getMimeType(), header.d); header.d[2] = static_cast(dirent.getParameter().size()); header.d[3] = dirent.getNamespace(); log_debug("title=" << dirent.getTitle() << " title.size()=" << dirent.getTitle().size()); toLittleEndian(dirent.getVersion(), header.d + 4); if (dirent.isRedirect()) { toLittleEndian(dirent.getRedirectIndex(), header.d + 8); out.write(header.d, 12); } else if (dirent.isLinktarget() || dirent.isDeleted()) { out.write(header.d, 8); } else { toLittleEndian(dirent.getClusterNumber(), header.d + 8); toLittleEndian(dirent.getBlobNumber(), header.d + 12); out.write(header.d, 16); } out << dirent.getUrl() << '\0'; std::string t = dirent.getTitle(); if (t != dirent.getUrl()) out << t; out << '\0' << dirent.getParameter(); return out; } std::istream& operator>> (std::istream& in, Dirent& dirent) { union { long a; char d[16]; } header; in.read(header.d, 8); if (in.fail()) { log_warn("error reading dirent header"); return in; } if (in.gcount() != 8) { log_warn("error reading dirent header (2)"); in.setstate(std::ios::failbit); return in; } uint16_t mimeType = fromLittleEndian(reinterpret_cast(header.d)); bool redirect = (mimeType == Dirent::redirectMimeType); bool linktarget = (mimeType == Dirent::linktargetMimeType); bool deleted = (mimeType == Dirent::deletedMimeType); char ns = header.d[3]; size_type version = fromLittleEndian(reinterpret_cast(header.d + 4)); dirent.setVersion(version); if (redirect) { in.read(header.d + 8, 4); if (in.fail()) { log_warn("error reading redirect dirent header"); return in; } size_type redirectIndex = fromLittleEndian(reinterpret_cast(header.d + 8)); log_debug("redirectIndex=" << redirectIndex); dirent.setRedirect(redirectIndex); } else if (linktarget || deleted) { log_debug("linktarget or deleted entry"); dirent.setArticle(mimeType, 0, 0); } else { log_debug("read article entry"); in.read(header.d + 8, 8); if (in.fail()) { log_warn("error reading article dirent header"); return in; } if (in.gcount() != 8) { log_warn("error reading article dirent header (2)"); in.setstate(std::ios::failbit); return in; } size_type clusterNumber = fromLittleEndian(reinterpret_cast(header.d + 8)); size_type blobNumber = fromLittleEndian(reinterpret_cast(header.d + 12)); log_debug("mimeType=" << mimeType << " clusterNumber=" << clusterNumber << " blobNumber=" << blobNumber); dirent.setArticle(mimeType, clusterNumber, blobNumber); } char ch; std::string url; std::string title; std::string parameter; log_debug("read url, title and parameters"); while (in.get(ch) && ch != '\0') url += ch; while (in.get(ch) && ch != '\0') title += ch; uint8_t extraLen = static_cast(header.d[2]); while (extraLen-- > 0 && in.get(ch)) parameter += ch; dirent.setUrl(ns, url); dirent.setTitle(title); dirent.setParameter(parameter); return in; } std::string Dirent::getLongUrl() const { log_trace("Dirent::getLongUrl()"); log_debug("namespace=" << getNamespace() << " title=" << getTitle()); return std::string(1, getNamespace()) + '/' + getUrl(); } } libzim-2.0.0/src/endian_tools.h000066400000000000000000000056151312444564200164310ustar00rootroot00000000000000/* * Copyright (C) 2006 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ENDIAN_H #define ENDIAN_H #include #include #include namespace zim { /// Returns true, if machine is big-endian (high byte first). /// e.g. PowerPC inline bool isBigEndian() { const int i = 1; return *reinterpret_cast(&i) == 0; } /// Returns true, if machine is little-endian (low byte first). /// e.g. x86 inline bool isLittleEndian() { const int i = 1; return *reinterpret_cast(&i) == 1; } //////////////////////////////////////////////////////////////////////// template void toLittleEndian(const T& d, char* dst, bool bigEndian = isBigEndian()) { if (bigEndian) { std::reverse_copy( reinterpret_cast(&d), reinterpret_cast(&d) + sizeof(T), dst); } else { std::copy( reinterpret_cast(&d), reinterpret_cast(&d) + sizeof(T), dst); } } template T fromLittleEndian(const T* ptr, bool bigEndian = isBigEndian()) { if (bigEndian) { T ret; std::reverse_copy(reinterpret_cast(ptr), reinterpret_cast(ptr) + sizeof(T), reinterpret_cast(&ret)); return ret; } else { return *ptr; } } //////////////////////////////////////////////////////////////////////// template void toBigEndian(const T& d, char* dst, bool bigEndian = isBigEndian()) { if (bigEndian) { std::copy( reinterpret_cast(&d), reinterpret_cast(&d) + sizeof(T), dst); } else { std::reverse_copy( reinterpret_cast(&d), reinterpret_cast(&d) + sizeof(T), dst); } } template T fromBigEndian(const T* ptr, bool bigEndian = isBigEndian()) { if (bigEndian) { return *ptr; } else { T ret; std::reverse_copy(reinterpret_cast(ptr), reinterpret_cast(ptr) + sizeof(T), reinterpret_cast(&ret)); return ret; } } } #endif // ENDIAN_H libzim-2.0.0/src/envvalue.cpp000066400000000000000000000027141312444564200161300ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include namespace zim { unsigned envValue(const char* env, unsigned def) { const char* v = ::getenv(env); if (v) { std::istringstream s(v); s >> def; } return def; } unsigned envMemSize(const char* env, unsigned def) { const char* v = ::getenv(env); if (v) { char unit = '\0'; std::istringstream s(v); s >> def >> unit; switch (unit) { case 'k': case 'K': def *= 1024; break; case 'm': case 'M': def *= 1024 * 1024; break; case 'g': case 'G': def *= 1024 * 1024 * 1024; break; } } return def; } } libzim-2.0.0/src/envvalue.h000066400000000000000000000017511312444564200155750ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_ENVVALUE_H #define ZIM_ENVVALUE_H namespace zim { unsigned envValue(const char* env, unsigned def); unsigned envMemSize(const char* env, unsigned def); } #endif // ZIM_ENVVALUE_H libzim-2.0.0/src/file.cpp000066400000000000000000000203201312444564200152130ustar00rootroot00000000000000/* * Copyright (C) 2006,2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #include #include "log.h" #include #include log_define("zim.file") namespace zim { namespace { int hexval(char ch) { if (ch >= '0' && ch <= '9') return ch - '0'; if (ch >= 'a' && ch <= 'f') return ch - 'a' + 10; if (ch >= 'A' && ch <= 'F') return ch - 'A' + 10; return -1; } } Article File::getArticle(size_type idx) const { if (idx >= getCountArticles()) throw ZimFileFormatError("article index out of range"); return Article(*this, idx); } Article File::getArticle(char ns, const std::string& url) const { log_trace("File::getArticle('" << ns << "', \"" << url << ')'); std::pair r = findx(ns, url); return r.first ? *r.second : Article(); } Article File::getArticleByUrl(const std::string& url) const { log_trace("File::getArticle(\"" << url << ')'); std::pair r = findx(url); return r.first ? *r.second : Article(); } Article File::getArticleByTitle(size_type idx) const { return Article(*this, impl->getIndexByTitle(idx)); } Article File::getArticleByTitle(char ns, const std::string& title) const { log_trace("File::getArticleByTitle('" << ns << "', \"" << title << ')'); std::pair r = findxByTitle(ns, title); return r.first ? *r.second : Article(); } bool File::hasNamespace(char ch) const { size_type off = getNamespaceBeginOffset(ch); return off < getCountArticles() && getDirent(off).getNamespace() == ch; } File::const_iterator File::begin() const { return const_iterator(this, 0); } File::const_iterator File::beginByTitle() const { return const_iterator(this, 0, const_iterator::ArticleIterator); } File::const_iterator File::end() const { return const_iterator(this, getCountArticles()); } std::pair File::findx(char ns, const std::string& url) const { log_debug("find article by url " << ns << " \"" << url << "\", in file \"" << getFilename() << '"'); size_type l = getNamespaceBeginOffset(ns); size_type u = getNamespaceEndOffset(ns); if (l == u) { log_debug("namespace " << ns << " not found"); return std::pair(false, end()); } unsigned itcount = 0; while (u - l > 1) { ++itcount; size_type p = l + (u - l) / 2; Dirent d = getDirent(p); int c = ns < d.getNamespace() ? -1 : ns > d.getNamespace() ? 1 : url.compare(d.getUrl()); if (c < 0) u = p; else if (c > 0) l = p; else { log_debug("article found after " << itcount << " iterations in file \"" << getFilename() << "\" at index " << p); return std::pair(true, const_iterator(this, p)); } } Dirent d = getDirent(l); int c = url.compare(d.getUrl()); if (c == 0) { log_debug("article found after " << itcount << " iterations in file \"" << getFilename() << "\" at index " << l); return std::pair(true, const_iterator(this, l)); } log_debug("article not found after " << itcount << " iterations (\"" << d.getUrl() << "\" does not match)"); return std::pair(false, const_iterator(this, c < 0 ? l : u)); } std::pair File::findx(const std::string& url) const { if (url.size() < 2 || url[1] != '/') return std::pair(false, const_iterator()); return findx(url[0], url.substr(2)); } std::pair File::findxByTitle(char ns, const std::string& title) const { log_debug("find article by title " << ns << " \"" << title << "\", in file \"" << getFilename() << '"'); size_type l = getNamespaceBeginOffset(ns); size_type u = getNamespaceEndOffset(ns); if (l == u) { log_debug("namespace " << ns << " not found"); return std::pair(false, end()); } unsigned itcount = 0; while (u - l > 1) { ++itcount; size_type p = l + (u - l) / 2; Dirent d = getDirentByTitle(p); int c = ns < d.getNamespace() ? -1 : ns > d.getNamespace() ? 1 : title.compare(d.getTitle()); if (c < 0) u = p; else if (c > 0) l = p; else { log_debug("article found after " << itcount << " iterations in file \"" << getFilename() << "\" at index " << p); return std::pair(true, const_iterator(this, p, const_iterator::ArticleIterator)); } } Dirent d = getDirentByTitle(l); int c = title.compare(d.getTitle()); if (c == 0) { log_debug("article found after " << itcount << " iterations in file \"" << getFilename() << "\" at index " << l); return std::pair(true, const_iterator(this, l, const_iterator::ArticleIterator)); } log_debug("article not found after " << itcount << " iterations (\"" << d.getTitle() << "\" does not match)"); return std::pair(false, const_iterator(this, c < 0 ? l : u, const_iterator::ArticleIterator)); } File::const_iterator File::find(char ns, const std::string& url) const { return findx(ns, url).second; } File::const_iterator File::find(const std::string& url) const { return findx(url).second; } File::const_iterator File::findByTitle(char ns, const std::string& title) const { return findxByTitle(ns, title).second; } const Search* File::search(const std::string& query, int start, int end) const { Search* search = new Search(this); search->set_query(query); search->set_range(start, end); return search; } offset_type File::getOffset(size_type clusterIdx, size_type blobIdx) const { Cluster cluster = getCluster(clusterIdx); if (cluster.isCompressed()) return 0; return cluster.getBlobOffset(blobIdx); } std::string urldecode(const std::string& url) { std::string ret; enum { state_0, state_h1, state_h2 } state = state_0; char ch = '\0'; for (std::string::const_iterator it = url.begin(); it != url.end(); ++it) { switch (state) { case state_0: if (*it == '+') ret += ' '; else if (*it == '%') state = state_h1; else ret += *it; break; case state_h1: if ( (*it >= '0' && *it <= '9') || (*it >= 'A' && *it <= 'F') || (*it >= 'a' && *it <= 'f')) { ch = *it; state = state_h2; } else { ret += '%'; ret += *it; state = state_0; } break; case state_h2: if ( (*it >= '0' && *it <= '9') || (*it >= 'A' && *it <= 'F') || (*it >= 'a' && *it <= 'f')) { ret += static_cast(hexval(ch) * 16 + hexval(*it)); } else { ret += static_cast(hexval(ch)); ret += *it; } state = state_0; break; } } switch (state) { case state_0: break; case state_h1: ret += '%'; break; case state_h2: ret += '%'; ret += ch; break; } return ret; } } libzim-2.0.0/src/fileheader.cpp000066400000000000000000000102221312444564200163640ustar00rootroot00000000000000/* * Copyright (C) 2008 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #include #include "log.h" #include "endian_tools.h" log_define("zim.file.header") namespace zim { const size_type Fileheader::zimMagic = 0x044d495a; // ="ZIM^d" const size_type Fileheader::zimVersion = 5; const size_type Fileheader::size = 80; std::ostream& operator<< (std::ostream& out, const Fileheader& fh) { char header[Fileheader::size]; toLittleEndian(Fileheader::zimMagic, header); toLittleEndian(Fileheader::zimVersion, header + 4); std::copy(fh.getUuid().data, fh.getUuid().data + sizeof(Uuid), header + 8); toLittleEndian(fh.getArticleCount(), header + 24); toLittleEndian(fh.getClusterCount(), header + 28); toLittleEndian(fh.getUrlPtrPos(), header + 32); toLittleEndian(fh.getTitleIdxPos(), header + 40); toLittleEndian(fh.getClusterPtrPos(), header + 48); toLittleEndian(fh.getMimeListPos(), header + 56); toLittleEndian(fh.getMainPage(), header + 64); toLittleEndian(fh.getLayoutPage(), header + 68); toLittleEndian(fh.getChecksumPos(), header + 72); out.write(header, Fileheader::size); return out; } std::istream& operator>> (std::istream& in, Fileheader& fh) { char header[Fileheader::size]; in.read(header, Fileheader::size); if (in.fail()) return in; if (static_cast(in.gcount()) != Fileheader::size) { in.setstate(std::ios::failbit); return in; } size_type magicNumber = fromLittleEndian(reinterpret_cast(header)); if (magicNumber != Fileheader::zimMagic) { log_error("invalid magic number " << magicNumber << " found - " << Fileheader::zimMagic << " expected"); in.setstate(std::ios::failbit); return in; } uint16_t version = fromLittleEndian(reinterpret_cast(header + 4)); if (version != static_cast(Fileheader::zimVersion)) { log_error("invalid zimfile version " << version << " found - " << Fileheader::zimVersion << " expected"); in.setstate(std::ios::failbit); return in; } Uuid uuid; std::copy(header + 8, header + 24, uuid.data); size_type articleCount = fromLittleEndian(reinterpret_cast(header + 24)); size_type clusterCount = fromLittleEndian(reinterpret_cast(header + 28)); offset_type urlPtrPos = fromLittleEndian(reinterpret_cast(header + 32)); offset_type titleIdxPos = fromLittleEndian(reinterpret_cast(header + 40)); offset_type clusterPtrPos = fromLittleEndian(reinterpret_cast(header + 48)); offset_type mimeListPos = fromLittleEndian(reinterpret_cast(header + 56)); size_type mainPage = fromLittleEndian(reinterpret_cast(header + 64)); size_type layoutPage = fromLittleEndian(reinterpret_cast(header + 68)); offset_type checksumPos = fromLittleEndian(reinterpret_cast(header + 72)); fh.setUuid(uuid); fh.setArticleCount(articleCount); fh.setClusterCount(clusterCount); fh.setUrlPtrPos(urlPtrPos); fh.setTitleIdxPos(titleIdxPos); fh.setClusterPtrPos(clusterPtrPos); fh.setMimeListPos(mimeListPos); fh.setMainPage(mainPage); fh.setLayoutPage(layoutPage); fh.setChecksumPos(checksumPos); return in; } } libzim-2.0.0/src/fileimpl.cpp000066400000000000000000000231671312444564200161110ustar00rootroot00000000000000/* * Copyright (C) 2006,2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #include #include "endian_tools.h" #include #include #include #include #include #include "config.h" #include "log.h" #include "envvalue.h" #include "md5stream.h" log_define("zim.file.impl") namespace zim { ////////////////////////////////////////////////////////////////////// // FileImpl // FileImpl::FileImpl(const char* fname) : zimFile(fname), direntCache(envValue("ZIM_DIRENTCACHE", DIRENT_CACHE_SIZE)), clusterCache(envValue("ZIM_CLUSTERCACHE", CLUSTER_CACHE_SIZE)), cacheUncompressedCluster(envValue("ZIM_CACHEUNCOMPRESSEDCLUSTER", false)) { log_trace("read file \"" << fname << '"'); if (!zimFile) throw ZimFileFormatError(std::string("can't open zim-file \"") + fname + '"'); filename = fname; // read header zimFile >> header; if (zimFile.fail()) throw ZimFileFormatError("error reading zim-file header"); if (getCountClusters() == 0) log_warn("no clusters found"); else { offset_type lastOffset = getClusterOffset(getCountClusters() - 1); log_debug("last offset=" << lastOffset << " file size=" << zimFile.fsize()); if (lastOffset > static_cast(zimFile.fsize())) { log_fatal("last offset (" << lastOffset << ") larger than file size (" << zimFile.fsize() << ')'); throw ZimFileFormatError("last cluster offset larger than file size; file corrupt"); } } // read mime types zimFile.seekg(header.getMimeListPos()); std::string mimeType; while (true) { std::getline(zimFile, mimeType, '\0'); if (zimFile.fail()) throw ZimFileFormatError("error reading mime type list"); if (mimeType.empty()) break; mimeTypes.push_back(mimeType);; } } Dirent FileImpl::getDirent(size_type idx) { log_trace("FileImpl::getDirent(" << idx << ')'); zimFile.setBufsize(64); if (idx >= getCountArticles()) throw ZimFileFormatError("article index out of range"); if (!zimFile) { log_warn("file in error state"); throw ZimFileFormatError("file in error state"); } std::pair v = direntCache.getx(idx); if (v.first) { log_debug("dirent " << idx << " found in cache; hits " << direntCache.getHits() << " misses " << direntCache.getMisses() << " ratio " << direntCache.hitRatio() * 100 << "% fillfactor " << direntCache.fillfactor()); return v.second; } log_debug("dirent " << idx << " not found in cache; hits " << direntCache.getHits() << " misses " << direntCache.getMisses() << " ratio " << direntCache.hitRatio() * 100 << "% fillfactor " << direntCache.fillfactor()); offset_type indexOffset = getOffset(header.getUrlPtrPos(), idx); zimFile.seekg(indexOffset); if (!zimFile) { log_warn("failed to seek to directory entry"); throw ZimFileFormatError("failed to seek to directory entry"); } Dirent dirent; zimFile >> dirent; if (!zimFile) { log_warn("failed to read to directory entry"); throw ZimFileFormatError("failed to read directory entry"); } log_debug("dirent read from " << indexOffset); direntCache.put(idx, dirent); return dirent; } Dirent FileImpl::getDirentByTitle(size_type idx) { if (idx >= getCountArticles()) throw ZimFileFormatError("article index out of range"); return getDirent(getIndexByTitle(idx)); } size_type FileImpl::getIndexByTitle(size_type idx) { if (idx >= getCountArticles()) throw ZimFileFormatError("article index out of range"); zimFile.seekg(header.getTitleIdxPos() + sizeof(size_type) * idx); size_type ret; zimFile.read(reinterpret_cast(&ret), sizeof(size_type)); if (!zimFile) throw ZimFileFormatError("error reading title index"); if (isBigEndian()) ret = fromLittleEndian(&ret); return ret; } Cluster FileImpl::getCluster(size_type idx) { log_trace("getCluster(" << idx << ')'); if (idx >= getCountClusters()) throw ZimFileFormatError("cluster index out of range"); Cluster cluster = clusterCache.get(idx); if (cluster) { log_debug("cluster " << idx << " found in cache; hits " << clusterCache.getHits() << " misses " << clusterCache.getMisses() << " ratio " << clusterCache.hitRatio() * 100 << "% fillfactor " << clusterCache.fillfactor()); return cluster; } zimFile.setBufsize(16384); offset_type clusterOffset = getClusterOffset(idx); log_debug("read cluster " << idx << " from offset " << clusterOffset); cluster.init_from_stream(zimFile, clusterOffset); if (zimFile.fail()) throw ZimFileFormatError("error reading cluster data"); if (cacheUncompressedCluster || cluster.isCompressed()) { log_debug("put cluster " << idx << " into cluster cache; hits " << clusterCache.getHits() << " misses " << clusterCache.getMisses() << " ratio " << clusterCache.hitRatio() * 100 << "% fillfactor " << clusterCache.fillfactor()); clusterCache.put(idx, cluster); } else log_debug("cluster " << idx << " is not compressed - do not cache"); return cluster; } offset_type FileImpl::getOffset(offset_type ptrOffset, size_type idx) { zimFile.seekg(ptrOffset + sizeof(offset_type) * idx); offset_type offset; zimFile.read(reinterpret_cast(&offset), sizeof(offset_type)); if (!zimFile) throw ZimFileFormatError("error reading offset"); if (isBigEndian()) offset = fromLittleEndian(&offset); return offset; } size_type FileImpl::getNamespaceBeginOffset(char ch) { log_trace("getNamespaceBeginOffset(" << ch << ')'); NamespaceCache::const_iterator it = namespaceBeginCache.find(ch); if (it != namespaceBeginCache.end()) return it->second; size_type lower = 0; size_type upper = getCountArticles(); Dirent d = getDirent(0); while (upper - lower > 1) { size_type m = lower + (upper - lower) / 2; Dirent d = getDirent(m); if (d.getNamespace() >= ch) upper = m; else lower = m; } size_type ret = d.getNamespace() < ch ? upper : lower; namespaceBeginCache[ch] = ret; return ret; } size_type FileImpl::getNamespaceEndOffset(char ch) { log_trace("getNamespaceEndOffset(" << ch << ')'); NamespaceCache::const_iterator it = namespaceEndCache.find(ch); if (it != namespaceEndCache.end()) return it->second; size_type lower = 0; size_type upper = getCountArticles(); log_debug("namespace " << ch << " lower=" << lower << " upper=" << upper); while (upper - lower > 1) { size_type m = lower + (upper - lower) / 2; Dirent d = getDirent(m); if (d.getNamespace() > ch) upper = m; else lower = m; log_debug("namespace " << d.getNamespace() << " m=" << m << " lower=" << lower << " upper=" << upper); } namespaceEndCache[ch] = upper; return upper; } std::string FileImpl::getNamespaces() { if (namespaces.empty()) { Dirent d = getDirent(0); namespaces = d.getNamespace(); size_type idx; while ((idx = getNamespaceEndOffset(d.getNamespace())) < getCountArticles()) { d = getDirent(idx); namespaces += d.getNamespace(); } } return namespaces; } const std::string& FileImpl::getMimeType(uint16_t idx) const { if (idx > mimeTypes.size()) { std::ostringstream msg; msg << "unknown mime type code " << idx; throw std::runtime_error(msg.str()); } return mimeTypes[idx]; } std::string FileImpl::getChecksum() { if (!header.hasChecksum()) return std::string(); zimFile.seekg(header.getChecksumPos()); unsigned char chksum[16]; zimFile.read(reinterpret_cast(chksum), 16); if (!zimFile) { log_warn("error reading checksum"); return std::string(); } char hexdigest[33]; hexdigest[32] = '\0'; static const char hex[] = "0123456789abcdef"; char* p = hexdigest; for (int i = 0; i < 16; ++i) { *p++ = hex[chksum[i] >> 4]; *p++ = hex[chksum[i] & 0xf]; } log_debug("chksum=" << hexdigest); return hexdigest; } bool FileImpl::verify() { if (!header.hasChecksum()) return false; Md5stream md5; zimFile.seekg(0); char ch; for (offset_type n = 0; n < header.getChecksumPos() && zimFile.get(ch); ++n) md5 << ch; unsigned char chksumFile[16]; unsigned char chksumCalc[16]; zimFile.read(reinterpret_cast(chksumFile), 16); if (!zimFile) throw ZimFileFormatError("failed to read checksum from zim file"); md5.getDigest(chksumCalc); if (std::memcmp(chksumFile, chksumCalc, 16) != 0) throw ZimFileFormatError("invalid checksum in zim file"); return true; } } libzim-2.0.0/src/fstream.cpp000066400000000000000000000145651312444564200157530ustar00rootroot00000000000000/* * Copyright (C) 2010 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include "log.h" #include "config.h" #include #include #include #include #include #include #include #ifdef _WIN32 #include #else #include #endif #ifndef O_LARGEFILE #define O_LARGEFILE 0 #endif #ifndef O_BINARY #define O_BINARY 0 #endif log_define("zim.fstream") namespace zim { class FileNotFound : public std::runtime_error { public: FileNotFound() : std::runtime_error("file not found") { } }; //////////////////////////////////////////////////////////// // OpenfileInfo // streambuf::OpenfileInfo::OpenfileInfo(const std::string& fname_) : fname(fname_), #ifdef HAVE_OPEN64 fd(::open64(fname.c_str(), O_RDONLY | O_LARGEFILE | O_BINARY)) #else fd(::open(fname.c_str(), O_RDONLY | O_LARGEFILE | O_BINARY)) #endif { if (fd < 0) throw FileNotFound(); } streambuf::OpenfileInfo::~OpenfileInfo() { ::close(fd); } //////////////////////////////////////////////////////////// // FileInfo // streambuf::FileInfo::FileInfo(const std::string& fname_, int fd) : fname(fname_) { #if defined(_WIN32) __int64 ret = ::_lseeki64(fd, 0, SEEK_END); #elif defined(HAVE_LSEEK64) off64_t ret = ::lseek64(fd, 0, SEEK_END); #else off_t ret = ::lseek(fd, 0, SEEK_END); #endif if (ret < 0) { std::ostringstream msg; msg << "error " << errno << " seeking to end in file " << fname << ": " << strerror(errno); throw std::runtime_error(msg.str()); } fsize = static_cast(ret); } std::streambuf::int_type streambuf::overflow(std::streambuf::int_type ch) { return traits_type::eof(); } std::streambuf::int_type streambuf::underflow() { log_debug("underflow; bufsize=" << buffer.size()); int n; do { n = ::read(currentFile->fd, &buffer[0], buffer.size()); if (n < 0) { std::ostringstream msg; msg << "error " << errno << " reading from file: " << strerror(errno); throw std::runtime_error(msg.str()); } else if (n == 0) { FilesType::iterator it; for (it = files.begin(); it != files.end(); ++it) { if ((*it)->fname == currentFile->fname) { ++it; break; } } if (it == files.end()) return traits_type::eof(); setCurrentFile((*it)->fname, 0); } } while (n == 0); char* p = &buffer[0]; setg(p, p, p + n); return traits_type::to_int_type(*gptr()); } int streambuf::sync() { return traits_type::eof(); } streambuf::streambuf(const std::string& fname, unsigned bufsize, unsigned noOpenFiles) : buffer(bufsize), openFilesCache(noOpenFiles), mtime(0) { log_debug("streambuf for " << fname << " with " << bufsize << " bytes"); try { currentFile = new OpenfileInfo(fname); files.push_back(new FileInfo(fname, currentFile->fd)); openFilesCache.put(fname, currentFile); } catch (const FileNotFound&) { int errnoSave = errno; try { for (char ch0 = 'a'; ch0 <= 'z'; ++ch0) { std::string fname0 = fname + ch0; for (char ch1 = 'a'; ch1 <= 'z'; ++ch1) { std::string fname1 = fname0 + ch1; currentFile = new OpenfileInfo(fname1); files.push_back(new FileInfo(fname1, currentFile->fd)); openFilesCache.put(fname1, currentFile); } } } catch (const FileNotFound&) { if (files.empty()) { std::ostringstream msg; msg << "error " << errnoSave << " opening file \"" << fname << "\": " << strerror(errnoSave); throw std::runtime_error(msg.str()); } } } setCurrentFile((*files.begin())->fname, 0); } void streambuf::setCurrentFile(const std::string& fname, zim::offset_type off) { std::pair f = openFilesCache.getx(fname); if (f.first) { currentFile = f.second; } else { // file not found in cache currentFile = new OpenfileInfo(fname); openFilesCache.put(fname, currentFile); } if (f.first || off != 0) // found in cache or seek requested { #if defined(_WIN32) offset_type ret = ::_lseeki64(currentFile->fd, off, SEEK_SET); #elif defined(HAVE_LSEEK64) off64_t ret = ::lseek64(currentFile->fd, off, SEEK_SET); #else off_t ret = ::lseek(currentFile->fd, off, SEEK_SET); #endif if (ret < 0) { std::ostringstream msg; msg << "error " << errno << " seeking to "<< off << " in file " << fname << ": " << strerror(errno); throw std::runtime_error(msg.str()); } } setg(0, 0, 0); } void streambuf::seekg(zim::offset_type off) { setg(0, 0, 0); zim::offset_type o = off; FilesType::iterator it; for (it = files.begin(); it != files.end() && (*it)->fsize < o; ++it) o -= (*it)->fsize; if (it == files.end()) { std::ostringstream msg; msg << "error seeking to "<< off; throw std::runtime_error(msg.str()); } setCurrentFile((*it)->fname, o); } zim::offset_type streambuf::fsize() const { zim::offset_type o = 0; for (FilesType::const_iterator it = files.begin(); it != files.end(); ++it) o += (*it)->fsize; return o; } time_t streambuf::getMTime() const { if (mtime || files.empty()) return mtime; const char* fname = files.front()->fname.c_str(); #if defined(HAVE_STAT64) && ! defined(__APPLE__) struct stat64 st; int ret = ::stat64(fname, &st); #else struct stat st; int ret = ::stat(fname, &st); #endif if (ret != 0) { std::ostringstream msg; msg << "stat failed with errno " << errno << " : " << strerror(errno); throw std::runtime_error(msg.str()); } mtime = st.st_mtime; return mtime; } } libzim-2.0.0/src/inflatestream.cpp000066400000000000000000000100521312444564200171330ustar00rootroot00000000000000/* inflatestream.cpp * Copyright (C) 2003-2005 Tommi Maekitalo * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * */ #include "inflatestream.h" #include "log.h" #include log_define("zim.inflatestream") namespace zim { namespace { int checkError(int ret, z_stream& stream) { if (ret != Z_OK && ret != Z_STREAM_END) { log_error("InflateError " << ret << ": \"" << (stream.msg ? stream.msg : "") << '"'); std::ostringstream msg; msg << "inflate-error " << ret; if (stream.msg) msg << ": " << stream.msg; throw InflateError(ret, msg.str()); } return ret; } } InflateStreamBuf::InflateStreamBuf(std::streambuf* sinksource_, unsigned bufsize_) : iobuffer(new char_type[bufsize_]), bufsize(bufsize_), sinksource(sinksource_) { stream.zalloc = Z_NULL; stream.zfree = Z_NULL; stream.opaque = 0; stream.total_out = 0; stream.total_in = 0; stream.next_in = Z_NULL; stream.avail_in = 0; checkError(::inflateInit(&stream), stream); } InflateStreamBuf::~InflateStreamBuf() { ::inflateEnd(&stream); delete[] iobuffer; } InflateStreamBuf::int_type InflateStreamBuf::overflow(int_type c) { if (pptr()) { // initialize input-stream for stream.next_in = (Bytef*)obuffer(); stream.avail_in = pptr() - pbase(); int ret; do { // initialize ibuffer stream.next_out = (Bytef*)ibuffer(); stream.avail_out = ibuffer_size(); ret = ::inflate(&stream, Z_SYNC_FLUSH); checkError(ret, stream); // copy zbuffer to sinksource std::streamsize count = ibuffer_size() - stream.avail_out; std::streamsize n = sinksource->sputn(reinterpret_cast(ibuffer()), count); if (n < count) return traits_type::eof(); } while (ret != Z_STREAM_END && stream.avail_in > 0); } // reset outbuffer setp(obuffer(), obuffer() + obuffer_size()); if (c != traits_type::eof()) sputc(traits_type::to_char_type(c)); return 0; } InflateStreamBuf::int_type InflateStreamBuf::underflow() { // read from sinksource and decompress into obuffer stream.next_out = (Bytef*)obuffer(); stream.avail_out = obuffer_size(); do { // fill ibuffer first if needed if (stream.avail_in == 0) { if (sinksource->in_avail() > 0) { // there is data already available // read compressed data from source into ibuffer stream.avail_in = sinksource->sgetn(ibuffer(), std::min(sinksource->in_avail(), ibuffer_size())); } else { // no data available stream.avail_in = sinksource->sgetn(ibuffer(), ibuffer_size()); if (stream.avail_in == 0) return traits_type::eof(); } stream.next_in = (Bytef*)ibuffer(); } // we decompress it now into obuffer // at least one character received from source - pass to decompressor int ret = ::inflate(&stream, Z_SYNC_FLUSH); checkError(ret, stream); setg(obuffer(), obuffer(), obuffer() + obuffer_size() - stream.avail_out); } while (gptr() == egptr()); return sgetc(); } int InflateStreamBuf::sync() { if (pptr() && overflow(traits_type::eof()) == traits_type::eof()) return -1; return 0; } } libzim-2.0.0/src/inflatestream.h000066400000000000000000000057161312444564200166130ustar00rootroot00000000000000/* * Copyright (C) 2005-2008 Tommi Maekitalo * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_INFLATESTREAM_H #define ZIM_INFLATESTREAM_H #include #include #include namespace zim { class InflateError : public std::runtime_error { int zRet; public: InflateError(int zRet_, const std::string& msg) : std::runtime_error(msg), zRet(zRet_) { } int getRet() const { return zRet; } }; class InflateStreamBuf : public std::streambuf { z_stream stream; char_type* iobuffer; unsigned bufsize; std::streambuf* sinksource; char_type* ibuffer() { return iobuffer; } std::streamsize ibuffer_size() { return bufsize >> 1; } char_type* obuffer() { return iobuffer + ibuffer_size(); } std::streamsize obuffer_size() { return bufsize >> 1; } public: explicit InflateStreamBuf(std::streambuf* sinksource_, unsigned bufsize = 8192); ~InflateStreamBuf(); /// see std::streambuf int_type overflow(int_type c); /// see std::streambuf int_type underflow(); /// see std::streambuf int sync(); void setSinksource(std::streambuf* sinksource_) { sinksource = sinksource_; } uLong getAdler() const { return stream.adler; } }; class InflateStream : public std::iostream { InflateStreamBuf streambuf; public: explicit InflateStream(std::streambuf* sinksource, unsigned bufsize = 8192) : std::iostream(0), streambuf(sinksource, bufsize) { init(&streambuf); } explicit InflateStream(std::ios& sinksource, unsigned bufsize = 8192) : std::iostream(0), streambuf(sinksource.rdbuf(), bufsize) { init(&streambuf); } void setSinksource(std::streambuf* sinksource) { streambuf.setSinksource(sinksource); } void setSinksource(std::ios& sinksource) { streambuf.setSinksource(sinksource.rdbuf()); } void setSink(std::ostream& sink) { streambuf.setSinksource(sink.rdbuf()); } void setSource(std::istream& source) { streambuf.setSinksource(source.rdbuf()); } uLong getAdler() const { return streambuf.getAdler(); } }; } #endif // ZIM_INFLATESTREAM_H libzim-2.0.0/src/log.h000066400000000000000000000020361312444564200145260ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include "config.h" #ifdef WITH_CXXTOOLS #include #else #define log_define(e) #define log_fatal(e) #define log_error(e) #define log_warn(e) #define log_info(e) #define log_debug(e) #define log_trace(e) #define log_init() #endif libzim-2.0.0/src/lzmastream.cpp000066400000000000000000000124021312444564200164550ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include "lzmastream.h" #include #include "log.h" #include #include log_define("zim.lzma.compress") namespace zim { namespace { lzma_ret checkError(lzma_ret ret) { if (ret != LZMA_OK && ret != LZMA_STREAM_END) { std::ostringstream msg; msg << "lzma-error " << ret; switch (ret) { case LZMA_OK: msg << ": LZMA_OK"; break; case LZMA_STREAM_END: msg << ": LZMA_STREAM_END"; break; case LZMA_NO_CHECK: msg << ": LZMA_NO_CHECK"; break; case LZMA_UNSUPPORTED_CHECK: msg << ": LZMA_UNSUPPORTED_CHECK"; break; case LZMA_GET_CHECK: msg << ": LZMA_GET_CHECK"; break; case LZMA_MEM_ERROR: msg << ": LZMA_MEM_ERROR"; break; case LZMA_MEMLIMIT_ERROR: msg << ": LZMA_MEMLIMIT_ERROR"; break; case LZMA_FORMAT_ERROR: msg << ": LZMA_FORMAT_ERROR"; break; case LZMA_OPTIONS_ERROR: msg << ": LZMA_OPTIONS_ERROR"; break; case LZMA_DATA_ERROR: msg << ": LZMA_DATA_ERROR"; break; case LZMA_BUF_ERROR: msg << ": LZMA_BUF_ERROR"; break; case LZMA_PROG_ERROR: msg << ": LZMA_PROG_ERROR"; break; } log_error(msg.str()); throw LzmaError(ret, msg.str()); } return ret; } } LzmaStreamBuf::LzmaStreamBuf(std::streambuf* sink_, uint32_t preset, lzma_check check, unsigned bufsize_) : obuffer(bufsize_), sink(sink_) { std::memset(reinterpret_cast(&stream), 0, sizeof(stream)); checkError( ::lzma_easy_encoder(&stream, preset, check)); setp(&obuffer[0], &obuffer[0] + obuffer.size()); } LzmaStreamBuf::~LzmaStreamBuf() { ::lzma_end(&stream); } LzmaStreamBuf::int_type LzmaStreamBuf::overflow(int_type c) { // initialize input-stream stream.next_in = reinterpret_cast(&obuffer[0]); stream.avail_in = pptr() - &obuffer[0]; // initialize zbuffer for compressed data char zbuffer[8192]; stream.next_out = reinterpret_cast(zbuffer); stream.avail_out = sizeof(zbuffer); // compress checkError(::lzma_code(&stream, LZMA_RUN)); // copy zbuffer to sink / consume deflated data std::streamsize count = sizeof(zbuffer) - stream.avail_out; if (count > 0) { std::streamsize n = sink->sputn(zbuffer, count); if (n < count) return traits_type::eof(); } // move remaining characters to start of obuffer if (stream.avail_in > 0) memmove(&obuffer[0], stream.next_in, stream.avail_in); // reset outbuffer setp(&obuffer[0] + stream.avail_in, &obuffer[0] + obuffer.size()); if (c != traits_type::eof()) sputc(traits_type::to_char_type(c)); return 0; } LzmaStreamBuf::int_type LzmaStreamBuf::underflow() { return traits_type::eof(); } int LzmaStreamBuf::sync() { // initialize input-stream for stream.next_in = reinterpret_cast(&obuffer[0]); stream.avail_in = pptr() - &obuffer[0]; char zbuffer[8192]; while (stream.avail_in > 0) { // initialize zbuffer stream.next_out = (uint8_t*)zbuffer; stream.avail_out = sizeof(zbuffer); checkError(::lzma_code(&stream, LZMA_FINISH)); // copy zbuffer to sink std::streamsize count = sizeof(zbuffer) - stream.avail_out; if (count > 0) { std::streamsize n = sink->sputn(zbuffer, count); if (n < count) return -1; } }; // reset outbuffer setp(&obuffer[0], &obuffer[0] + obuffer.size()); return 0; } int LzmaStreamBuf::end() { char zbuffer[8192]; // initialize input-stream for stream.next_in = reinterpret_cast(&obuffer[0]); stream.avail_in = pptr() - &obuffer[0]; lzma_ret ret; do { // initialize zbuffer stream.next_out = (uint8_t*)zbuffer; stream.avail_out = sizeof(zbuffer); ret = checkError(::lzma_code(&stream, LZMA_FINISH)); // copy zbuffer to sink std::streamsize count = sizeof(zbuffer) - stream.avail_out; if (count > 0) { std::streamsize n = sink->sputn(zbuffer, count); if (n < count) throw LzmaError(static_cast(0), "failed to send compressed data to sink in lzmastream"); } } while (ret != LZMA_STREAM_END); // reset outbuffer setp(&obuffer[0], &obuffer[0] + obuffer.size()); return 0; } void LzmaStream::end() { if (streambuf.end() != 0) setstate(failbit); } } libzim-2.0.0/src/lzmastream.h000066400000000000000000000053411312444564200161260ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_LZMASTREAM_H #define ZIM_LZMASTREAM_H #include #include #include #include namespace zim { class LzmaError : public std::runtime_error { lzma_ret ret; public: LzmaError(lzma_ret ret_, const std::string& msg) : std::runtime_error(msg), ret(ret_) { } lzma_ret getRetcode() const { return ret; } }; class LzmaStreamBuf : public std::streambuf { lzma_stream stream; std::vector obuffer; std::streambuf* sink; public: LzmaStreamBuf(std::streambuf* sink_, uint32_t preset = 3 | LZMA_PRESET_EXTREME, lzma_check check = LZMA_CHECK_CRC32 /* LZMA_CHECK_NONE */, unsigned bufsize = 8192); ~LzmaStreamBuf(); /// see std::streambuf int_type overflow(int_type c); /// see std::streambuf int_type underflow(); /// see std::streambuf int sync(); /// end stream int end(); void setSink(std::streambuf* sink_) { sink = sink_; } }; class LzmaStream : public std::ostream { LzmaStreamBuf streambuf; public: explicit LzmaStream(std::streambuf* sink, uint32_t preset = 3 | LZMA_PRESET_EXTREME, lzma_check check = LZMA_CHECK_CRC32 /* LZMA_CHECK_NONE */, unsigned bufsize = 8192) : std::ostream(0), streambuf(sink, preset, check, bufsize) { init(&streambuf); } explicit LzmaStream(std::ostream& sink, uint32_t preset = 3 | LZMA_PRESET_EXTREME, lzma_check check = LZMA_CHECK_CRC32 /* LZMA_CHECK_NONE */, unsigned bufsize = 8192) : std::ostream(0), streambuf(sink.rdbuf(), preset, check, bufsize) { init(&streambuf); } void end(); void setSink(std::streambuf* sink) { streambuf.setSink(sink); } void setSink(std::ostream& sink) { streambuf.setSink(sink.rdbuf()); } }; } #endif // ZIM_LZMASTREAM_H libzim-2.0.0/src/md5.c000066400000000000000000000241311312444564200144250ustar00rootroot00000000000000/* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm */ /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All rights reserved. License to copy and use this software is granted provided that it is identified as the "RSA Data Security, Inc. MD5 Message-Digest Algorithm" in all material mentioning or referencing this software or this function. License is also granted to make and use derivative works provided that such works are identified as "derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm" in all material mentioning or referencing the derived work. RSA Data Security, Inc. makes no representations concerning either the merchantability of this software or the suitability of this software for any particular purpose. It is provided "as is" without express or implied warranty of any kind. These notices must be retained in any copies of any part of this documentation and/or software. */ #include "md5.h" #include #define MD5_CTX struct zim_MD5_CTX /* Constants for MD5Transform routine. */ #define S11 7 #define S12 12 #define S13 17 #define S14 22 #define S21 5 #define S22 9 #define S23 14 #define S24 20 #define S31 4 #define S32 11 #define S33 16 #define S34 23 #define S41 6 #define S42 10 #define S43 15 #define S44 21 static void MD5Transform PROTO_LIST ((UINT4 [4], const unsigned char [64])); static void Encode PROTO_LIST ((unsigned char *, UINT4 *, unsigned int)); static void Decode PROTO_LIST ((UINT4 *, const unsigned char *, unsigned int)); /* static void MD5_memcpy PROTO_LIST ((POINTER, POINTER, unsigned int)); static void MD5_memset PROTO_LIST ((POINTER, int, unsigned int)); */ #define MD5_memcpy memcpy #define MD5_memset memset static unsigned char PADDING[64] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; /* F, G, H and I are basic MD5 functions. */ #define F(x, y, z) (((x) & (y)) | ((~x) & (z))) #define G(x, y, z) (((x) & (z)) | ((y) & (~z))) #define H(x, y, z) ((x) ^ (y) ^ (z)) #define I(x, y, z) ((y) ^ ((x) | (~z))) /* ROTATE_LEFT rotates x left n bits. */ #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. Rotation is separate from addition to prevent recomputation. */ #define FF(a, b, c, d, x, s, ac) { \ (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \ (a) = ROTATE_LEFT ((a), (s)); \ (a) += (b); \ } #define GG(a, b, c, d, x, s, ac) { \ (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \ (a) = ROTATE_LEFT ((a), (s)); \ (a) += (b); \ } #define HH(a, b, c, d, x, s, ac) { \ (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \ (a) = ROTATE_LEFT ((a), (s)); \ (a) += (b); \ } #define II(a, b, c, d, x, s, ac) { \ (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \ (a) = ROTATE_LEFT ((a), (s)); \ (a) += (b); \ } /* MD5 initialization. Begins an MD5 operation, writing a new context. */ void zim_MD5Init (MD5_CTX* context) { context->count[0] = context->count[1] = 0; /* Load magic initialization constants. */ context->state[0] = 0x67452301; context->state[1] = 0xefcdab89; context->state[2] = 0x98badcfe; context->state[3] = 0x10325476; } /* MD5 block update operation. Continues an MD5 message-digest operation, processing another message block, and updating the context. */ void zim_MD5Update ( MD5_CTX *context, const unsigned char *input, /* input block */ unsigned int inputLen) /* length of input block */ { unsigned int i, index, partLen; /* Compute number of bytes mod 64 */ index = (unsigned int)((context->count[0] >> 3) & 0x3F); /* Update number of bits */ if ((context->count[0] += ((UINT4)inputLen << 3)) < ((UINT4)inputLen << 3)) context->count[1]++; context->count[1] += ((UINT4)inputLen >> 29); partLen = 64 - index; /* Transform as many times as possible. */ if (inputLen >= partLen) { MD5_memcpy ((POINTER)&context->buffer[index], (POINTER)input, partLen); MD5Transform (context->state, context->buffer); for (i = partLen; i + 63 < inputLen; i += 64) MD5Transform (context->state, &input[i]); index = 0; } else i = 0; /* Buffer remaining input */ MD5_memcpy ((POINTER)&context->buffer[index], (POINTER)&input[i], inputLen-i); } /* MD5 finalization. Ends an MD5 message-digest operation, writing the the message digest and zeroizing the context. */ void zim_MD5Final ( unsigned char digest[16], /* message digest */ MD5_CTX *context) /* context */ { unsigned char bits[8]; unsigned int index, padLen; /* Save number of bits */ Encode (bits, context->count, 8); /* Pad out to 56 mod 64. */ index = (unsigned int)((context->count[0] >> 3) & 0x3f); padLen = (index < 56) ? (56 - index) : (120 - index); zim_MD5Update (context, PADDING, padLen); /* Append length (before padding) */ zim_MD5Update (context, bits, 8); /* Store state in digest */ Encode (digest, context->state, 16); /* Zeroize sensitive information. */ MD5_memset ((POINTER)context, 0, sizeof (*context)); } /* MD5 basic transformation. Transforms state based on block. */ static void MD5Transform ( UINT4 state[4], const unsigned char block[64]) { UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16]; Decode (x, block, 64); /* Round 1 */ FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */ FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */ FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */ FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */ FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */ FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */ FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */ FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */ FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */ FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */ FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */ FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */ FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */ FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */ FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */ FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */ /* Round 2 */ GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */ GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */ GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */ GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */ GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */ GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */ GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */ GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */ GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */ GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */ GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */ GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */ GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */ GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */ GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */ GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */ /* Round 3 */ HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */ HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */ HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */ HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */ HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */ HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */ HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */ HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */ HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */ HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */ HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */ HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */ HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */ HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */ HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */ HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */ /* Round 4 */ II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */ II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */ II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */ II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */ II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */ II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */ II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */ II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */ II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */ II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */ II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */ II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */ II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */ II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */ II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */ II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */ state[0] += a; state[1] += b; state[2] += c; state[3] += d; /* Zeroize sensitive information. */ MD5_memset ((POINTER)x, 0, sizeof (x)); } /* Encodes input (UINT4) into output (unsigned char). Assumes len is a multiple of 4. */ static void Encode ( unsigned char *output, UINT4 *input, unsigned int len) { unsigned int i, j; for (i = 0, j = 0; j < len; i++, j += 4) { output[j] = (unsigned char)(input[i] & 0xff); output[j+1] = (unsigned char)((input[i] >> 8) & 0xff); output[j+2] = (unsigned char)((input[i] >> 16) & 0xff); output[j+3] = (unsigned char)((input[i] >> 24) & 0xff); } } /* Decodes input (unsigned char) into output (UINT4). Assumes len is a multiple of 4. */ static void Decode ( UINT4 *output, const unsigned char *input, unsigned int len) { unsigned int i, j; for (i = 0, j = 0; j < len; i++, j += 4) output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) | (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24); } #if 0 /* Note: Replace "for loop" with standard memcpy if possible. */ static void MD5_memcpy ( POINTER output, POINTER input, unsigned int len) { unsigned int i; for (i = 0; i < len; i++) output[i] = input[i]; } /* Note: Replace "for loop" with standard memset if possible. */ static void MD5_memset ( POINTER output, int value, unsigned int len) { unsigned int i; for (i = 0; i < len; i++) ((char *)output)[i] = (char)value; } #endif libzim-2.0.0/src/md5.h000066400000000000000000000070441312444564200144360ustar00rootroot00000000000000/* * Copyright (C) 2003 Tommi Maekitalo * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * As a special exception, you may use this file as part of a free * software library without restriction. Specifically, if other files * instantiate templates or use macros or inline functions from this * file, or you compile this file and link it with other files to * produce an executable, this file does not by itself cause the * resulting executable to be covered by the GNU General Public * License. This exception does not however invalidate any other * reasons why the executable file might be covered by the GNU Library * General Public License. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All rights reserved. License to copy and use this software is granted provided that it is identified as the "RSA Data Security, Inc. MD5 Message-Digest Algorithm" in all material mentioning or referencing this software or this function. License is also granted to make and use derivative works provided that such works are identified as "derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm" in all material mentioning or referencing the derived work. RSA Data Security, Inc. makes no representations concerning either the merchantability of this software or the suitability of this software for any particular purpose. It is provided "as is" without express or implied warranty of any kind. These notices must be retained in any copies of any part of this documentation and/or software. */ /* RSAREF types and constants */ /* PROTOTYPES should be set to one if and only if the compiler supports function argument prototyping. The following makes PROTOTYPES default to 0 if it has not already been defined with C compiler flags. */ #ifndef ZIM_MD5_H #define ZIM_MD5_H #ifndef PROTOTYPES #define PROTOTYPES 1 #endif /* POINTER defines a generic pointer type */ typedef unsigned char *POINTER; /* UINT2 defines a two byte word */ typedef unsigned short int UINT2; /* UINT4 defines a four byte word */ typedef unsigned int UINT4; /* PROTO_LIST is defined depending on how PROTOTYPES is defined above. If using PROTOTYPES, then PROTO_LIST returns the list, otherwise it returns an empty list. */ #if PROTOTYPES #define PROTO_LIST(list) list #else #define PROTO_LIST(list) () #endif /* MD5 context. */ struct zim_MD5_CTX { UINT4 state[4]; /* state (ABCD) */ UINT4 count[2]; /* number of bits, modulo 2^64 (lsb first) */ unsigned char buffer[64]; /* input buffer */ }; #ifdef __cplusplus extern "C" { #endif void zim_MD5Init PROTO_LIST ((struct zim_MD5_CTX *)); void zim_MD5Update PROTO_LIST ((struct zim_MD5_CTX *, const unsigned char *, unsigned int)); void zim_MD5Final PROTO_LIST ((unsigned char [16], struct zim_MD5_CTX *)); #ifdef __cplusplus } #endif #endif /* ZIM_MD5_H */ libzim-2.0.0/src/md5stream.cpp000066400000000000000000000065601312444564200162070ustar00rootroot00000000000000/* * Copyright (C) 2003 Tommi Maekitalo * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * As a special exception, you may use this file as part of a free * software library without restriction. Specifically, if other files * instantiate templates or use macros or inline functions from this * file, or you compile this file and link it with other files to * produce an executable, this file does not by itself cause the * resulting executable to be covered by the GNU General Public * License. This exception does not however invalidate any other * reasons why the executable file might be covered by the GNU Library * General Public License. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "md5stream.h" #include "md5.h" #include namespace zim { //////////////////////////////////////////////////////////////////////// // Md5streambuf // Md5streambuf::Md5streambuf() : context(new zim_MD5_CTX()) { zim_MD5Init(context); } Md5streambuf::~Md5streambuf() { delete context; } std::streambuf::int_type Md5streambuf::overflow( std::streambuf::int_type ch) { if (pptr() == 0) { // Ausgabepuffer ist leer - initialisieren zim_MD5Init(context); } else { // konsumiere Zeichen aus dem Puffer zim_MD5Update(context, (const unsigned char*)pbase(), pptr() - pbase()); } // setze Ausgabepuffer setp(buffer, buffer + bufsize); if (ch != traits_type::eof()) { // das Zeichen, welches den overflow ausgelöst hat, stecken // wir in den Puffer. *pptr() = traits_type::to_char_type(ch); pbump(1); } return 0; } std::streambuf::int_type Md5streambuf::underflow() { // nur Ausgabestrom return traits_type::eof(); } int Md5streambuf::sync() { if (pptr() != pbase()) { // konsumiere Zeichen aus dem Puffer zim_MD5Update(context, (const unsigned char*)pbase(), pptr() - pbase()); // leere Ausgabepuffer setp(buffer, buffer + bufsize); } return 0; } void Md5streambuf::getDigest(unsigned char digest_[16]) { if (pptr()) { if (pptr() != pbase()) { // konsumiere Zeichen aus dem Puffer zim_MD5Update(context, (const unsigned char*)pbase(), pptr() - pbase()); } // deinitialisiere Ausgabepuffer setp(0, 0); } else { zim_MD5Init(context); } zim_MD5Final(digest, context); std::memcpy(digest_, digest, 16); } //////////////////////////////////////////////////////////////////////// // Md5stream // const char* Md5stream::getHexDigest() { static const char hex[] = "0123456789abcdef"; unsigned char md5[16]; getDigest(md5); int i; char* p = hexdigest; for (i = 0; i < 16; ++i) { *p++ = hex[md5[i] >> 4]; *p++ = hex[md5[i] & 0xf]; } *p = '\0'; return hexdigest; } } libzim-2.0.0/src/md5stream.h000066400000000000000000000061471312444564200156550ustar00rootroot00000000000000/* * Copyright (C) 2003 Tommi Maekitalo * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * As a special exception, you may use this file as part of a free * software library without restriction. Specifically, if other files * instantiate templates or use macros or inline functions from this * file, or you compile this file and link it with other files to * produce an executable, this file does not by itself cause the * resulting executable to be covered by the GNU General Public * License. This exception does not however invalidate any other * reasons why the executable file might be covered by the GNU Library * General Public License. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef ZIM_MD5STREAM_H #define ZIM_MD5STREAM_H #include struct zim_MD5_CTX; namespace zim { class Md5streambuf : public std::streambuf { public: Md5streambuf(); ~Md5streambuf(); void getDigest(unsigned char digest[16]); private: static const unsigned int bufsize = 64; char buffer[bufsize]; zim_MD5_CTX* context; unsigned char digest[16]; std::streambuf::int_type overflow(std::streambuf::int_type ch); std::streambuf::int_type underflow(); int sync(); }; /** This is a easy and safe interface to MD5-calculation. To get a MD5-sum of data, instantiate a md5stream, copy your data into it and read the digest. After calling getDigest or getHexDigest, the class can be reused for another md5-calculation. The algorithm is automatically reinitialized when the first character is received. example: \code int main(int argc, char* argv[]) { Md5stream s; for (int i = 1; i < argc; ++i) { std::ifstream in(argv[i]); if (in) { s << in.rdbuf(); std::cout << s.getHexDigest() << " " << argv[i] << std::endl; } } } \endcode */ class Md5stream : public std::ostream { public: typedef std::ostreambuf_iterator iterator; private: Md5streambuf streambuf; char hexdigest[33]; public: /// initializes md5-calculation Md5stream() : std::ostream(0) { init(&streambuf); } /// ends md5-calculation and returns 16 bytes digest void getDigest(unsigned char digest[16]) { streambuf.getDigest(digest); } /// ends md5-calculation and digest as 32 bytes hex const char* getHexDigest(); /// returns output-iterator to Md5stream iterator begin() { return iterator(&streambuf); } }; } #endif // ZIM_MD5STREAM_H libzim-2.0.0/src/meson.build000066400000000000000000000023701312444564200157370ustar00rootroot00000000000000 configure_file(output : 'config.h', configuration : conf, input : 'config.h.in') common_sources = [ # 'config.h', 'article.cpp', 'articlesource.cpp', 'cluster.cpp', 'dirent.cpp', 'envvalue.cpp', 'file.cpp', 'fileheader.cpp', 'fileimpl.cpp', 'fstream.cpp', 'md5.c', 'md5stream.cpp', 'ptrstream.cpp', 'search.cpp', 'search_iterator.cpp', 'tee.cpp', 'template.cpp', 'unicode.cpp', 'uuid.cpp', 'zimcreator.cpp', 'zintstream.cpp' ] zlib_sources = [ 'deflatestream.cpp', 'inflatestream.cpp' ] lzma_sources = [ 'lzmastream.cpp', 'unlzmastream.cpp' ] xapian_sources = [ 'xapian/htmlparse.cc', 'xapian/myhtmlparse.cc' ] sources = common_sources deps = [] if zlib_dep.found() sources += zlib_sources deps += [zlib_dep] endif if lzma_dep.found() sources += lzma_sources deps += [lzma_dep] endif if xapian_dep.found() sources += xapian_sources deps += [xapian_dep, icu_dep] endif libzim = library('zim', sources, include_directories : inc, dependencies : deps, version: meson.project_version(), install : true) subdir('tools') libzim-2.0.0/src/ptrstream.cpp000066400000000000000000000021031312444564200163140ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include "ptrstream.h" namespace zim { std::streambuf::int_type ptrstreambuf::overflow(int_type c) { return traits_type::eof(); } std::streambuf::int_type ptrstreambuf::underflow() { return traits_type::eof(); } int ptrstreambuf::sync() { return 0; } } libzim-2.0.0/src/ptrstream.h000066400000000000000000000027051312444564200157710ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_PTRSTREAM_H #define ZIM_PTRSTREAM_H #include namespace zim { class ptrstreambuf : public std::streambuf { public: ptrstreambuf(char* start, char* end) { setp(start, end); setg(start, start, end); } /// see std::streambuf int_type overflow(int_type c); /// see std::streambuf int_type underflow(); /// see std::streambuf int sync(); }; class ptrstream : public std::iostream { ptrstreambuf streambuf; public: ptrstream(char* start, char* end) : std::iostream(0), streambuf(start, end) { init(&streambuf); } }; } #endif libzim-2.0.0/src/search.cpp000066400000000000000000000161361312444564200155530ustar00rootroot00000000000000/* * Copyright (C) 2007 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include "search_internal.h" #include #include #include #include #include #if defined(ENABLE_XAPIAN) #include "xapian.h" #include #endif namespace zim { namespace { /* Split string in a token array */ std::vector split(const std::string & str, const std::string & delims=" *-") { std::string::size_type lastPos = str.find_first_not_of(delims, 0); std::string::size_type pos = str.find_first_of(delims, lastPos); std::vector tokens; while (std::string::npos != pos || std::string::npos != lastPos) { tokens.push_back(str.substr(lastPos, pos - lastPos)); lastPos = str.find_first_not_of(delims, pos); pos = str.find_first_of(delims, lastPos); } return tokens; } std::map read_valuesmap(const std::string &s) { std::map result; std::vector elems = split(s, ";"); for(std::vector::iterator elem = elems.begin(); elem != elems.end(); elem++) { std::vector tmp_elems = split(*elem, ":"); result.insert( std::pair(tmp_elems[0], atoi(tmp_elems[1].c_str())) ); } return result; } } Search::Search(const std::vector zimfiles) : internal(new InternalData), zimfiles(zimfiles), search_started(false), has_database(false) {} Search::Search(const File* zimfile) : internal(new InternalData), search_started(false), has_database(false) { zimfiles.push_back(zimfile); } Search::Search(const Search& it) : internal(new InternalData), zimfiles(it.zimfiles), query(it.query), range_start(it.range_start), range_end(it.range_end), search_started(false), has_database(false) { } Search& Search::operator=(const Search& it) { if ( internal ) internal.reset(); zimfiles = it.zimfiles; query = it.query; range_start = it.range_start; range_end = it.range_end; search_started = false; has_database = false; return *this; } Search::Search(Search&& it) = default; Search& Search::operator=(Search&& it) = default; Search::~Search() = default; Search& Search::add_zimfile(const File* zimfile) { zimfiles.push_back(zimfile); return *this; } Search& Search::set_query(const std::string& query) { this->query = query; return *this; } Search& Search::set_range(int start, int end) { this->range_start = start; this->range_end = end; return *this; } #if defined(ENABLE_XAPIAN) void setup_queryParser(Xapian::QueryParser* queryparser, Xapian::Database& database, const std::string& language, const std::string& stopwords) { queryparser->set_database(database); if ( ! language.empty() ) { /* Build ICU Local object to retrieve ISO-639 language code (from ISO-639-3) */ icu::Locale languageLocale(language.c_str()); /* Configuring language base steemming */ try { Xapian::Stem stemmer = Xapian::Stem(languageLocale.getLanguage()); queryparser->set_stemmer(stemmer); queryparser->set_stemming_strategy(Xapian::QueryParser::STEM_ALL); } catch (...) { std::cout << "No steemming for language '" << languageLocale.getLanguage() << "'" << std::endl; } } if ( ! stopwords.empty() ) { std::string stopWord; std::istringstream file(stopwords); Xapian::SimpleStopper* stopper = new Xapian::SimpleStopper(); while (std::getline(file, stopWord, '\n')) { stopper->add(stopWord); } stopper->release(); queryparser->set_stopper(stopper); } } #endif Search::iterator Search::begin() const { #if defined(ENABLE_XAPIAN) if ( this->search_started ) { return new search_iterator::InternalData(this, internal->results.begin()); } std::vector::const_iterator it; bool first = true; std::string language; std::string stopwords; for(it=zimfiles.begin(); it!=zimfiles.end(); it++) { const File* zimfile = *it; zim::Article xapianArticle = zimfile->getArticle('Z', "/fulltextIndex/xapian"); if (!xapianArticle.good()) { continue; } zim::offset_type dbOffset = xapianArticle.getOffset(); int databasefd = open(zimfile->getFilename().c_str(), O_RDONLY); lseek(databasefd, dbOffset, SEEK_SET); Xapian::Database database(databasefd); if ( first ) { this->valuesmap = read_valuesmap(database.get_metadata("valuesmap")); language = database.get_metadata("language"); stopwords = database.get_metadata("stopwords"); } else { std::map valuesmap = read_valuesmap(database.get_metadata("valuesmap")); if (this->valuesmap != valuesmap ) { // [TODO] Ignore the database, raise a error ? } } internal->xapian_databases.push_back(database); internal->database.add_database(database); has_database = true; } if ( ! has_database ) { estimated_matches_number = 0; return nullptr; } Xapian::QueryParser* queryParser = new Xapian::QueryParser(); setup_queryParser(queryParser, internal->database, language, stopwords); Xapian::Query query = queryParser->parse_query(this->query); delete queryParser; Xapian::Enquire enquire(internal->database); enquire.set_query(query); internal->results = enquire.get_mset(this->range_start, this->range_end-this->range_start); search_started = true; estimated_matches_number = internal->results.get_matches_estimated(); return new search_iterator::InternalData(this, internal->results.begin()); #else estimated_matches_number = 0; return nullptr; #endif } Search::iterator Search::end() const { #if defined(ENABLE_XAPIAN) if ( ! has_database ) { return nullptr; } return new search_iterator::InternalData(this, internal->results.end()); #else return nullptr; #endif } int Search::get_matches_estimated() const { // Ensure that the search as begin begin(); return estimated_matches_number; } } //namespace zim libzim-2.0.0/src/search_internal.h000066400000000000000000000046051312444564200171120ustar00rootroot00000000000000/* * Copyright (C) 2006 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_SEARCH_INTERNAL_H #define ZIM_SEARCH_INTERNAL_H #include "config.h" #if defined(ENABLE_XAPIAN) #include #endif namespace zim { struct Search::InternalData { #if defined(ENABLE_XAPIAN) std::vector xapian_databases; Xapian::Database database; Xapian::MSet results; #endif }; struct search_iterator::InternalData { #if defined(ENABLE_XAPIAN) const Search* search; Xapian::MSetIterator iterator; Xapian::Document _document; bool document_fetched; #endif Article _article; bool article_fetched; #if defined(ENABLE_XAPIAN) InternalData(const Search* search, Xapian::MSetIterator iterator) : search(search), iterator(iterator), document_fetched(false) {}; Xapian::Document get_document() { if ( !document_fetched ) { if (iterator != search->internal->results.end()) { _document = iterator.get_document(); } document_fetched = true; } return _document; } #endif Article& get_article() { #if defined(ENABLE_XAPIAN) if ( !article_fetched ) { Xapian::docid docid = *iterator; int databasenumber = (docid - 1) % search->zimfiles.size(); const File* file = search->zimfiles[databasenumber]; if ( ! file ) _article = Article(); else _article = file->getArticleByUrl(get_document().get_data()); article_fetched = true; } #endif return _article; } }; }; //namespace zim #endif //ZIM_SEARCH_INTERNAL_H libzim-2.0.0/src/search_iterator.cpp000066400000000000000000000135731312444564200174660ustar00rootroot00000000000000 #include "xapian/myhtmlparse.h" #include #include #include "search_internal.h" namespace zim { search_iterator::~search_iterator() = default; search_iterator::search_iterator(search_iterator&& it) = default; search_iterator& search_iterator::operator=(search_iterator&& it) = default; search_iterator::search_iterator() : search_iterator(nullptr) {}; search_iterator::search_iterator(InternalData* internal_data) : internal(internal_data) {} search_iterator::search_iterator(const search_iterator& it) : internal(nullptr) { if (it.internal) internal = std::unique_ptr(new InternalData(*it.internal)); } search_iterator & search_iterator::operator=(const search_iterator& it) { if ( ! it.internal ) internal.reset(); else if ( ! internal ) internal = std::unique_ptr(new InternalData(*it.internal)); else *internal = *it.internal; return *this; } bool search_iterator::operator==(const search_iterator& it) const { #if defined(ENABLE_XAPIAN) if ( ! internal && ! it.internal) return true; if ( ! internal || ! it.internal) return false; return (internal->search == it.internal->search && internal->iterator == it.internal->iterator); #else // If there is no xapian, there is no search. There is only one iterator: end. // So all iterators are equal. return true; #endif } bool search_iterator::operator!=(const search_iterator& it) const { return ! (*this == it); } search_iterator& search_iterator::operator++() { #if defined(ENABLE_XAPIAN) if ( ! internal ) { return *this; } ++(internal->iterator); internal->document_fetched = false; internal->article_fetched = false; #endif return *this; } search_iterator search_iterator::operator++(int) { search_iterator it = *this; operator++(); return it; } search_iterator& search_iterator::operator--() { #if defined(ENABLE_XAPIAN) if ( ! internal ) { return *this; } --(internal->iterator); internal->document_fetched = false; internal->article_fetched = false; #endif return *this; } search_iterator search_iterator::operator--(int) { search_iterator it = *this; operator--(); return it; } std::string search_iterator::get_url() const { #if defined(ENABLE_XAPIAN) if ( ! internal ) { return ""; } return internal->get_document().get_data(); #else return ""; #endif } std::string search_iterator::get_title() const { #if defined(ENABLE_XAPIAN) if ( ! internal ) { return ""; } if ( internal->search->valuesmap.empty() ) { /* This is the old legacy version. Guess and try */ return internal->get_document().get_value(0); } else if ( internal->search->valuesmap.find("title") != internal->search->valuesmap.end() ) { return internal->get_document().get_value(internal->search->valuesmap["title"]); } #endif return ""; } int search_iterator::get_score() const { #if defined(ENABLE_XAPIAN) if ( ! internal ) { return 0; } return internal->iterator.get_percent(); #else return 0; #endif } std::string search_iterator::get_snippet() const { #if defined(ENABLE_XAPIAN) if ( ! internal ) { return ""; } if ( internal->search->valuesmap.empty() ) { /* This is the old legacy version. Guess and try */ std::string stored_snippet = internal->get_document().get_value(1); if ( ! stored_snippet.empty() ) return stored_snippet; /* Let's continue here, and see if we can genenate one */ } else if ( internal->search->valuesmap.find("snippet") != internal->search->valuesmap.end() ) { return internal->get_document().get_value(internal->search->valuesmap["snippet"]); } /* No reader, no snippet */ Article& article = internal->get_article(); if ( ! article.good() ) return ""; /* Get the content of the article to generate a snippet. We parse it and use the html dump to avoid remove html tags in the content and be able to nicely cut the text at random place. */ zim::MyHtmlParser htmlParser; std::string content = article.getData(); try { htmlParser.parse_html(content, "UTF-8", true); } catch (...) {} return internal->search->internal->results.snippet(htmlParser.dump, 500); #else return ""; #endif } int search_iterator::get_size() const { #if defined(ENABLE_XAPIAN) if ( ! internal ) { return -1; } if ( internal->search->valuesmap.empty() ) { /* This is the old legacy version. Guess and try */ return internal->get_document().get_value(2).empty() == true ? -1 : atoi(internal->get_document().get_value(2).c_str()); } else if ( internal->search->valuesmap.find("size") != internal->search->valuesmap.end() ) { return atoi(internal->get_document().get_value(internal->search->valuesmap["size"]).c_str()); } #endif /* The size is never used. Do we really want to get the content and calculate the size ? */ return -1; } int search_iterator::get_wordCount() const { #if defined(ENABLE_XAPIAN) if ( ! internal ) { return -1; } if ( internal->search->valuesmap.empty() ) { /* This is the old legacy version. Guess and try */ return internal->get_document().get_value(3).empty() == true ? -1 : atoi(internal->get_document().get_value(3).c_str()); } else if ( internal->search->valuesmap.find("wordcount") != internal->search->valuesmap.end() ) { return atoi(internal->get_document().get_value(internal->search->valuesmap["wordcount"]).c_str()); } #endif return -1; } search_iterator::reference search_iterator::operator*() const { return internal->get_article(); } search_iterator::pointer search_iterator::operator->() const { return &internal->get_article(); } } // namespace zim libzim-2.0.0/src/tee.cpp000066400000000000000000000046031312444564200150570ustar00rootroot00000000000000/* * Copyright (C) 2003 Tommi Maekitalo * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * As a special exception, you may use this file as part of a free * software library without restriction. Specifically, if other files * instantiate templates or use macros or inline functions from this * file, or you compile this file and link it with other files to * produce an executable, this file does not by itself cause the * resulting executable to be covered by the GNU General Public * License. This exception does not however invalidate any other * reasons why the executable file might be covered by the GNU Library * General Public License. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "tee.h" namespace zim { std::streambuf::int_type Teestreambuf::overflow(std::streambuf::int_type ch) { if(ch != traits_type::eof()) { if(streambuf1 && streambuf1->sputc(ch) == traits_type::eof()) return traits_type::eof(); if(streambuf2 && streambuf2->sputc(ch) == traits_type::eof()) return traits_type::eof(); } return 0; } std::streambuf::int_type Teestreambuf::underflow() { return traits_type::eof(); } int Teestreambuf::sync() { if(streambuf1 && streambuf1->pubsync() == traits_type::eof()) return traits_type::eof(); if(streambuf2 && streambuf2->pubsync() == traits_type::eof()) return traits_type::eof(); return 0; } ///////////////////////////////////////////////////////////////////////////// void Tee::assign(std::ostream& s1, std::ostream& s2) { Teestreambuf* buf = dynamic_cast(rdbuf()); if(buf) buf->tie(s1.rdbuf(), s2.rdbuf()); } void Tee::assign_single(std::ostream& s) { Teestreambuf* buf = dynamic_cast(rdbuf()); if(buf) buf->tie(s.rdbuf()); } } libzim-2.0.0/src/tee.h000066400000000000000000000052521312444564200145250ustar00rootroot00000000000000/* * Copyright (C) 2003 Tommi Maekitalo * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * As a special exception, you may use this file as part of a free * software library without restriction. Specifically, if other files * instantiate templates or use macros or inline functions from this * file, or you compile this file and link it with other files to * produce an executable, this file does not by itself cause the * resulting executable to be covered by the GNU General Public * License. This exception does not however invalidate any other * reasons why the executable file might be covered by the GNU Library * General Public License. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef ZIM_TEE_H #define ZIM_TEE_H #include namespace zim { class Teestreambuf : public std::streambuf { public: Teestreambuf(std::streambuf* buf1 = 0, std::streambuf* buf2 = 0) : streambuf1(buf1), streambuf2(buf2) { setp(0, 0); } void tie(std::streambuf* buf1, std::streambuf* buf2 = 0) { streambuf1 = buf1; streambuf2 = buf2; } private: std::streambuf::int_type overflow(std::streambuf::int_type ch); std::streambuf::int_type underflow(); int sync(); std::streambuf* streambuf1; std::streambuf* streambuf2; }; ///////////////////////////////////////////////////////////////////////////// class Tee : public std::ostream { typedef std::ostream base_class; Teestreambuf streambuf; public: Tee() : std::ostream(0), streambuf(std::cout.rdbuf()) { init(&streambuf); } Tee(std::ostream& s1, std::ostream& s2) : std::ostream(0), streambuf(s1.rdbuf(), s2.rdbuf()) { init(&streambuf); } Tee(std::ostream& s) : std::ostream(0), streambuf(s.rdbuf(), std::cout.rdbuf()) { init(&streambuf); } void assign(std::ostream& s1, std::ostream& s2); void assign(std::ostream& s) { assign(s, std::cout); } void assign_single(std::ostream& s); }; } #endif // ZIM_TEE_H libzim-2.0.0/src/template.cpp000066400000000000000000000055651312444564200161250ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include namespace zim { void TemplateParser::state_data(char ch) { data += ch; if (ch == '<') { state = &TemplateParser::state_lt; save = data.size() - 1; } } void TemplateParser::state_lt(char ch) { data += ch; if (ch == '%') state = &TemplateParser::state_token0; else state = &TemplateParser::state_data; } void TemplateParser::state_token0(char ch) { data += ch; if (ch == '/') state = &TemplateParser::state_link0; else { token = data.size() - 1; state = &TemplateParser::state_token; } } void TemplateParser::state_token(char ch) { data += ch; if (ch == '%') state = &TemplateParser::state_token_end; } void TemplateParser::state_token_end(char ch) { if (ch == '>') { if (event) { event->onData(data.substr(0, save)); event->onToken(data.substr(token, data.size() - token - 1)); data.clear(); } state = &TemplateParser::state_data; } else { data += ch; state = &TemplateParser::state_data; } } void TemplateParser::state_link0(char ch) { data += ch; ns = ch; state = &TemplateParser::state_link; } void TemplateParser::state_link(char ch) { data += ch; if (ch == '/') { token = data.size(); state = &TemplateParser::state_title; } else state = &TemplateParser::state_data; } void TemplateParser::state_title(char ch) { data += ch; if (ch == '%') { token_e = data.size() - 1; state = &TemplateParser::state_title_end; } } void TemplateParser::state_title_end(char ch) { data += ch; if (ch == '>') { if (event) { event->onData(data.substr(0, save)); event->onLink(ns, data.substr(token, token_e - token)); } data.clear(); state = &TemplateParser::state_data; } } void TemplateParser::flush() { if (event) event->onData(data); data.clear(); state = &TemplateParser::state_data; } } libzim-2.0.0/src/tools/000077500000000000000000000000001312444564200147335ustar00rootroot00000000000000libzim-2.0.0/src/tools/Makefile.am000066400000000000000000000004311312444564200167650ustar00rootroot00000000000000AM_CPPFLAGS=-I$(top_srcdir)/include -I$(top_srcdir)/src if MAKE_BENCHMARK ZIMBENCH = zimbench endif bin_PROGRAMS = zimdump zimsearch $(ZIMBENCH) zimdump_SOURCES = zimDump.cpp zimsearch_SOURCES = zimSearch.cpp zimbench_SOURCES = zimBench.cpp LDADD = $(top_builddir)/src/libzim.la libzim-2.0.0/src/tools/ZInt.cpp000066400000000000000000000024061312444564200163250ustar00rootroot00000000000000/* * Copyright (C) 2007 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #include int main(int argc, char* argv[]) { try { log_init(); unsigned col = 0; zim::ZIntStream z(std::cin); unsigned n; while (z.get(n)) { std::cout << n; if (col++ >= 10) { std::cout << std::endl; col = 0; } else std::cout << ' '; } } catch (const std::exception& e) { std::cerr << e.what() << std::endl; } } libzim-2.0.0/src/tools/log.properties000066400000000000000000000003441312444564200176330ustar00rootroot00000000000000rootlogger=I logger.zeno=T #logger.zeno.indexer=T #logger.zeno.search=T #logger.zeno.indexarticle=T #logger.zeno.writer=T #logger.zeno.compressor=T #logger.zeno.bzip2.compress=T file=zeno.log #maxfilesize=10M #maxbackupindex=10 libzim-2.0.0/src/tools/meson.build000066400000000000000000000013211312444564200170720ustar00rootroot00000000000000 src_directory = include_directories('..') include_dirs = [src_directory, include_directory] executable('zimdump', 'zimDump.cpp', link_with: libzim, dependencies : deps, include_directories: include_dirs, install: true) executable('zimsearch', 'zimSearch.cpp', link_with: libzim, dependencies : deps, include_directories: include_dirs, install: true) cxxtools_dep = dependency('cxxtools', required:false) if cxxtools_dep.found() executable('zimbench', 'zimBench.cpp', link_with: libzim, dependencies : deps + [cxxtools_dep], include_directories: include_dirs, install: true) endif libzim-2.0.0/src/tools/zimBench.cpp000066400000000000000000000106701312444564200172020ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #include #include #include #include #include #include #include #include "../log.h" #include #include log_define("zim.bench") std::string randomUrl() { std::string url; for (unsigned n = 0; n < 10; ++n) url += static_cast('A' + rand() % 26); return url; } int main(int argc, char* argv[]) { try { log_init(); cxxtools::Arg count(argc, argv, 'n', 1000); // number of linear accessed articles cxxtools::Arg randomCount(argc, argv, 'r', count); // number of random accesses cxxtools::Arg distinctCount(argc, argv, 'd', randomCount); // number of distinct articles used for random access cxxtools::Arg ns(argc, argv, "--ns", 'A'); if (argc != 2) { std::cerr << "usage: " << argv[0] << " [options] zimfile\n" "\t-n number\tnumber of linear accessed articles (default 1000)\n" "\t-r number\tnumber of random accessed articles (default: same as -n)\n" "\t-d number\tnumber of distinct articles used for random access (default: same as -r)\n" << std::flush; return 1; } srand(time(0)); std::string filename = argv[1]; std::cout << "open file " << filename << std::endl; zim::File file(filename); // collect urls typedef std::set UrlsType; typedef std::vector RandomUrlsType; UrlsType urls; RandomUrlsType randomUrls; std::cout << "collect linear urls" << std::endl; for (zim::File::const_iterator it = file.begin(); it != file.end() && urls.size() < count; ++it) { log_debug("check url " << it->getUrl() << '\t' << urls.size() << " found"); if (!it->isRedirect()) urls.insert(it->getUrl()); } std::cout << urls.size() << " urls collected" << std::endl; std::cout << "collect random urls" << std::endl; while (randomUrls.size() < distinctCount) { zim::File::const_iterator it = file.find(ns, randomUrl()); log_debug("check url " << it->getUrl() << '\t' << randomUrls.size() << " found"); if (!it->isRedirect()) randomUrls.push_back(it->getUrl()); } std::cout << randomUrls.size() << " random urls collected" << std::endl; // reopen file file = zim::File(); file = zim::File(filename); // linear read std::cout << "linear:" << std::flush; cxxtools::Clock clock; clock.start(); unsigned size = 0; for (UrlsType::const_iterator it = urls.begin(); it != urls.end(); ++it) size += file.getArticle(ns, *it).getData().size(); cxxtools::Timespan t = clock.stop(); std::cout << "\tsize=" << size << "\tt=" << (t.totalMSecs() / 1000.0) << "s\t" << (static_cast(urls.size()) / t.totalMSecs() * 1000.0) << " articles/s" << std::endl; // reopen file file = zim::File(); file = zim::File(filename); // random access std::cout << "random:" << std::flush; clock.start(); size = 0; for (unsigned r = 0; r < randomCount; ++r) size += file.getArticle(ns, randomUrls[rand() % randomUrls.size()]).getData().size(); //for (UrlsType::const_iterator it = randomUrls.begin(); it != randomUrls.end(); ++it) //size += file.getArticle(ns, *it).getData().size(); t = clock.stop(); std::cout << "\tsize=" << size << "\tt=" << (t.totalMSecs() / 1000.0) << "s\t" << (static_cast(randomCount) / t.totalMSecs() * 1000.0) << " articles/s" << std::endl; } catch (const std::exception& e) { std::cerr << e.what() << std::endl; } } libzim-2.0.0/src/tools/zimDump.cpp000066400000000000000000000376651312444564200171050ustar00rootroot00000000000000/* * Copyright (C) 2006 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #include #include #include #include #include "../zintstream.h" #include "../arg.h" #include "../log.h" #include #include #include log_define("zim.dumper") class ZimDumper { zim::File file; zim::File::const_iterator pos; bool verbose; public: ZimDumper(const char* fname, bool titleSort) : file(fname), pos(titleSort ? file.beginByTitle() : file.begin()), verbose(false) { } void setVerbose(bool sw = true) { verbose = sw; } void printInfo(); void printNsInfo(char ch); void locateArticle(zim::size_type idx); void findArticle(char ns, const char* expr, bool title); void findArticleByUrl(const std::string& url); void dumpArticle(); void dumpIndex(); void printPage(); void listArticles(bool info, bool listTable, bool extra); void listArticle(const zim::Article& article, bool extra); void listArticleT(const zim::Article& article, bool extra); void listArticle(bool extra) { listArticle(*pos, extra); } void listArticleT(bool extra) { listArticleT(*pos, extra); } void dumpFiles(const std::string& directory); void verifyChecksum(); }; void ZimDumper::printInfo() { std::cout << "count-articles: " << file.getCountArticles() << "\n"; if (verbose) { std::string ns = file.getNamespaces(); std::cout << "namespaces: " << ns << '\n'; for (std::string::const_iterator it = ns.begin(); it != ns.end(); ++it) std::cout << "namespace " << *it << " size: " << file.getNamespaceCount(*it) << '\n'; } std::cout << "uuid: " << file.getFileheader().getUuid() << "\n" "article count: " << file.getFileheader().getArticleCount() << "\n" "mime list pos: " << file.getFileheader().getMimeListPos() << "\n" "url ptr pos: " << file.getFileheader().getUrlPtrPos() << "\n" "title idx pos: " << file.getFileheader().getTitleIdxPos() << "\n" "cluster count: " << file.getFileheader().getClusterCount() << "\n" "cluster ptr pos: " << file.getFileheader().getClusterPtrPos() << "\n"; if (file.getFileheader().hasChecksum()) std::cout << "checksum pos: " << file.getFileheader().getChecksumPos() << "\n" "checksum: " << file.getChecksum() << "\n"; else std::cout << "no checksum\n"; if (file.getFileheader().hasMainPage()) std::cout << "main page: " << file.getFileheader().getMainPage() << "\n"; else std::cout << "main page: " << "-\n"; if (file.getFileheader().hasLayoutPage()) std::cout << "layout page: " << file.getFileheader().getLayoutPage() << "\n"; else std::cout << "layout page: " << "-\n"; std::cout.flush(); } void ZimDumper::printNsInfo(char ch) { std::cout << "namespace " << ch << "\n" "lower bound idx: " << file.getNamespaceBeginOffset(ch) << "\n" "upper bound idx: " << file.getNamespaceEndOffset(ch) << std::endl; } void ZimDumper::locateArticle(zim::size_type idx) { log_debug("locateArticle(" << idx << ')'); pos = zim::File::const_iterator(&file, idx); } void ZimDumper::findArticle(char ns, const char* expr, bool title) { log_debug("findArticle(" << ns << ", " << expr << ')'); if (title) pos = file.findByTitle(ns, expr); else pos = file.find(ns, expr); log_debug("findArticle(" << ns << ", " << expr << ") => idx=" << pos.getIndex()); } void ZimDumper::findArticleByUrl(const std::string& url) { pos = file.find(url); } void ZimDumper::printPage() { log_trace("print page"); if(pos!=file.end()) { std::cout << pos->getPage() << std::flush; } } void ZimDumper::dumpArticle() { log_trace("dump article"); if(pos!=file.end()) { std::cout << pos->getData() << std::flush; } } void ZimDumper::dumpIndex() { log_trace("dump index"); if (pos->getNamespace() == 'X') { // prepare parameter stream std::istringstream paramstream(pos->getParameter()); zim::ZIntStream parameter(paramstream); // read flags unsigned flags, off=0; parameter.get(flags); if (!parameter) throw std::runtime_error("invalid index parameter data"); // process categories for (unsigned c = 0, flag = 1; c < 4; ++c, flag <<= 1) { if (!(flags & flag)) continue; // category empty unsigned len, idx, wpos; parameter.get(len).get(idx).get(wpos); if (!parameter) throw std::runtime_error("invalid index parameter data"); if (verbose) std::cout << 'c' << c << "\tidx=" << idx << "\tpos=" << wpos << std::endl; else std::cout << 'c' << c << '\t' << idx << ';' << wpos; // prepare data stream zim::Blob data = pos->getData(); if (off + len > data.size()) throw std::runtime_error("invalid index data"); std::string data_s(data.data() + off, len); std::istringstream stream(data_s); zim::ZIntStream in(stream); off += len; unsigned lastidx = 0, lastpos = 0; while (in.get(idx).get(wpos)) { unsigned oidx = idx; unsigned owpos = wpos; if (idx == 0) { idx = lastidx; lastpos = (wpos += lastpos); } else { lastidx = (idx += lastidx); lastpos = wpos; } if (verbose) std::cout << 'c' << c << "\tidx=" << oidx << " => " << idx << "\tpos=" << owpos << " => " << wpos << std::endl; else std::cout << '\t' << idx << ';' << wpos; } if (!verbose) std::cout << std::endl; } } else std::cout << "no index article\n"; } void ZimDumper::listArticles(bool info, bool listTable, bool extra) { log_trace("listArticles(" << info << ", " << extra << ") verbose=" << verbose); for (zim::File::const_iterator it = pos; it != file.end(); ++it) { if (listTable) listArticleT(*it, extra); else if (info) listArticle(*it, extra); else std::cout << it->getUrl() << '\n'; } } void ZimDumper::listArticle(const zim::Article& article, bool extra) { zim::Dirent dirent = article.getDirent(); std::cout << "url: " << dirent.getUrl() << "\n" "\ttitle: " << dirent.getTitle() << "\n" "\tidx: " << article.getIndex() << "\n" "\tnamespace: " << dirent.getNamespace() << "\n" "\ttype: " << (dirent.isRedirect() ? "redirect" : dirent.isLinktarget() ? "linktarget" : dirent.isDeleted() ? "deleted" : "article") << "\n"; if (dirent.isRedirect()) { std::cout << "\tredirect index: " << dirent.getRedirectIndex() << "\n"; } else if (dirent.isLinktarget()) { // nothing else } else if (dirent.isDeleted()) { // nothing else } else { std::cout << "\tmime-type: " << article.getMimeType() << "\n" "\tarticle size: " << article.getArticleSize() << "\n"; if (verbose) { zim::Cluster cluster = article.getCluster(); std::cout << "\tcluster number: " << dirent.getClusterNumber() << "\n" "\tcluster count: " << cluster.count() << "\n" "\tcluster size: " << cluster.size() << "\n" "\tcluster offset: " << file.getClusterOffset(dirent.getClusterNumber()) << "\n" "\tblob number: " << dirent.getBlobNumber() << "\n" "\tcompression: "; switch (cluster.getCompression()) { case zim::zimcompDefault: std::cout << "default"; break; case zim::zimcompNone: std::cout << "none"; break; case zim::zimcompZip: std::cout << "zip"; break; case zim::zimcompBzip2: std::cout << "bzip2 (not supported anymore)"; break; case zim::zimcompLzma: std::cout << "lzma"; break; default: std::cout << "unknown (" << static_cast(cluster.getCompression()) << ')'; break; } std::cout << "\n"; } } if (extra) { std::string parameter = dirent.getParameter(); std::cout << "\textra: "; static char hexdigit[] = "0123456789abcdef"; for (std::string::const_iterator it = parameter.begin(); it != parameter.end(); ++it) { unsigned val = static_cast(static_cast(*it)); std::cout << hexdigit[val >> 4] << hexdigit[val & 0xf] << ' '; } std::cout << ':'; if (parameter.size() > 1) { std::istringstream s(parameter); zim::ZIntStream in(s); unsigned val; while (in.get(val)) std::cout << '\t' << val; } std::cout << std::endl; } } void ZimDumper::listArticleT(const zim::Article& article, bool extra) { zim::Dirent dirent = article.getDirent(); std::cout << dirent.getNamespace() << '\t' << dirent.getUrl() << '\t' << dirent.getTitle() << '\t' << article.getIndex() << '\t' << (dirent.isRedirect() ? 'R' : dirent.isLinktarget() ? 'L' : dirent.isDeleted() ? 'D' : 'A'); if (dirent.isRedirect()) { std::cout << '\t' << dirent.getRedirectIndex(); } else if (dirent.isLinktarget()) { // nothing else } else if (dirent.isDeleted()) { // nothing else } else { std::cout << '\t' << dirent.getMimeType() << '\t' << article.getArticleSize(); if (verbose) { zim::Cluster cluster = article.getCluster(); std::cout << '\t' << dirent.getClusterNumber() << '\t' << cluster.count() << '\t' << cluster.size() << '\t' << file.getClusterOffset(dirent.getClusterNumber()) << '\t' << dirent.getBlobNumber() << '\t' << static_cast(cluster.getCompression()); } } if (extra) { std::string parameter = dirent.getParameter(); std::cout << '\t'; static char hexdigit[] = "0123456789abcdef"; for (std::string::const_iterator it = parameter.begin(); it != parameter.end(); ++it) { unsigned val = static_cast(static_cast(*it)); std::cout << hexdigit[val >> 4] << hexdigit[val & 0xf] << '\t'; } if (parameter.size() > 1) { std::istringstream s(parameter); zim::ZIntStream in(s); unsigned val; while (in.get(val)) std::cout << '\t' << val; } } std::cout << std::endl; } void ZimDumper::dumpFiles(const std::string& directory) { unsigned int truncatedFiles = 0; #if defined(_WIN32) ::mkdir(directory.c_str()); #else ::mkdir(directory.c_str(), 0777); #endif std::set ns; for (zim::File::const_iterator it = pos; it != file.end(); ++it) { std::string d = directory + '/' + it->getNamespace(); if (ns.find(it->getNamespace()) == ns.end()) #if defined(_WIN32) ::mkdir(d.c_str()); #else ::mkdir(d.c_str(), 0777); #endif std::string t = it->getTitle(); std::string::size_type p; while ((p = t.find('/')) != std::string::npos) t.replace(p, 1, "%2f"); if ( t.length() > 255 ) { std::ostringstream sspostfix, sst; sspostfix << (++truncatedFiles); sst << t.substr(0, 254-sspostfix.tellp()) << "~" << sspostfix.str(); t = sst.str(); } std::string f = d + '/' + t; std::ofstream out(f.c_str()); out << it->getData(); if (!out) throw std::runtime_error("error writing file " + f); } } void ZimDumper::verifyChecksum() { if (file.verify()) std::cout << "checksum ok" << std::endl; else std::cout << "no checksum" << std::endl; } int main(int argc, char* argv[]) { try { log_init(); zim::Arg fileinfo(argc, argv, 'F'); zim::Arg nsinfo(argc, argv, 'N'); zim::Arg info(argc, argv, 'i'); zim::Arg data(argc, argv, 'd'); zim::Arg page(argc, argv, 'p'); zim::Arg find(argc, argv, 'f'); zim::Arg url(argc, argv, 'u'); zim::Arg list(argc, argv, 'l'); zim::Arg tableList(argc, argv, 'L'); zim::Arg indexOffset(argc, argv, 'o'); zim::Arg extra(argc, argv, 'x'); zim::Arg ns(argc, argv, 'n', 'A'); // namespace zim::Arg dumpAll(argc, argv, 'D'); zim::Arg verbose(argc, argv, 'v'); zim::Arg zint(argc, argv, 'Z'); zim::Arg titleSort(argc, argv, 't'); zim::Arg verifyChecksum(argc, argv, 'C'); if (argc <= 1) { std::cerr << "usage: " << argv[0] << " [options] zimfile\n" "\n" "options:\n" " -F print fileinfo\n" " -N ns print info about namespace\n" " -i print info about articles\n" " -d print data of articles\n" " -p print page\n" " -f title find article\n" " -u url find article by url\n" " -t sort (and find) articles by title instead of url\n" " -l list articles\n" " -L list articles as table\n" " -o idx locate article by index\n" " -x print extra parameters\n" " -n ns specify namespace (default 'A')\n" " -D dir dump all files into directory\n" " -v verbose (print uncompressed length of articles when -i is set)\n" " (print namespaces with counts with -F)\n" " -Z dump index data\n" " -C verify checksum\n" "\n" "examples:\n" " " << argv[0] << " -F wikipedia.zim\n" " " << argv[0] << " -l wikipedia.zim\n" " " << argv[0] << " -f Auto -i wikipedia.zim\n" " " << argv[0] << " -f Auto -d wikipedia.zim\n" " " << argv[0] << " -f Auto -l wikipedia.zim\n" " " << argv[0] << " -f Auto -l -i -v wikipedia.zim\n" " " << argv[0] << " -o 123159 -l -i wikipedia.zim\n" << std::flush; return -1; } // initalize app ZimDumper app(argv[1], titleSort); app.setVerbose(verbose); // global info if (fileinfo) app.printInfo(); // namespace info if (nsinfo.isSet()) app.printNsInfo(nsinfo); // locate article if (indexOffset.isSet()) app.locateArticle(indexOffset); else if (find.isSet()) app.findArticle(ns, find, titleSort); else if (url.isSet()) app.findArticleByUrl(std::string(url)); // dump files if (dumpAll.isSet()) app.dumpFiles(dumpAll.getValue()); // print requested info if (data) app.dumpArticle(); else if (page) app.printPage(); else if (list || tableList) app.listArticles(info, tableList, extra); else if (info) app.listArticle(extra); else if (zint) app.dumpIndex(); if (verifyChecksum) app.verifyChecksum(); } catch (const std::exception& e) { std::cerr << e.what() << std::endl; return -2; } return 0; } libzim-2.0.0/src/tools/zimSearch.cpp000066400000000000000000000034401312444564200173650ustar00rootroot00000000000000/* * Copyright (C) 2007 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include "../log.h" #include "../arg.h" #include <../../include/zim/search.h> void zimSearch(zim::Search& search) { for (zim::Search::iterator it = search.begin(); it != search.end(); ++it) { std::cout << "article " << it->getIndex() << "\nscore " << it.get_score() << "\t:\t" << it->getTitle() << std::endl; } } int main(int argc, char* argv[]) { try { log_init(); if (argc <= 2) { std::cerr << "usage: " << argv[0] << " [-x indexfile] zimfile searchstring\n" "\n" "options\n" " -x indexfile specify indexfile\n" << std::endl; return 1; } std::string s = argv[2]; for (int a = 3; a < argc; ++a) { s += ' '; s += argv[a]; } zim::File zimfile(argv[1]); zim::Search search = zim::Search(&zimfile); search.set_query(s); zimSearch(search); } catch (const std::exception& e) { std::cerr << e.what() << std::endl; } } libzim-2.0.0/src/unicode.cpp000066400000000000000000050132711312444564200157360ustar00rootroot00000000000000/*************************************************************************** * Copyright (C) 2006-2007 Marc Boris Duerner * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU Library General Public License as * * published by the Free Software Foundation; either version 2 of the * * License, or (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU Library General Public * * License along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ #include "unicode.h" namespace zim { namespace { const unsigned short ctype_lookup1[68] = { 0, 104, 169, 257, 385, 402, 402, 498, 626, 626, 677, 755, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, 883, 402, 402, 402, 1011, 1011, 1011, 1012, 1011, 1011, 1011, 1012 }; const unsigned short ctype_lookup2[1140] = { 0, 127, 255, 382, 502, 582, 710, 837, 965, 1091, 1219, 1339, 1467, 1580, 1708, 1836, 1886, 1886, 2013, 2140, 2267, 2394, 2521, 2647, 2774, 2900, 3026, 3152, 3279, 3406, 3534, 3662, 3790, 3886, 4014, 4069, 4197, 4318, 4431, 4556, 4683, 4684, 4684, 4684, 4703, 4831, 4959, 5087, 5215, 5343, 5471, 5588, 1886, 1886, 1886, 1886, 1886, 1886, 5716, 1886, 5844, 5950, 6078, 6206, 6334, 6462, 6590, 6714, 6830, 6830, 6958, 7083, 7211, 7311, 7439, 7512, 7640, 7768, 7895, 8013, 7439, 7439, 6830, 8138, 6830, 6830, 8266, 1886, 1886, 1886, 1886, 1886, 1886, 8394, 7439, 8424, 8552, 8657, 8785, 8898, 9026, 9154, 7439, 7439, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 9282, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 9410, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 9538, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 9666, 9794, 9794, 9794, 9794, 9794, 9794, 9794, 9794, 9794, 9794, 9794, 9794, 9794, 9794, 9794, 9794, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 4684, 4684, 10050, 1886, 10178, 10256, 4684, 4684, 10339, 10451, 10579, 10697, 10825, 10938, 11066, 11194, 11322, 1886, 1886, 1886, 11450, 11578, 11706, 11804, 1886, 1886, 1886, 1886, 1886, 1886, 11932, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 7439, 12060, 12188, 12313, 1886, 1886, 12441, 1886, 12569, 12695, 12819, 12941, 12965, 13083, 13153, 13223, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 4684, 13351, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 4684, 4684, 4684, 4684, 13408, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 13535, 1886, 13663, 13679, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 1886, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 9922, 13807 }; // Planes upper const unsigned short upper_plane[68]= { 0, 74, 74, 76, 203, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74 }; // Blocks upper const unsigned short upper_block[331]= { 0, 123, 251, 379, 499, 627, 686, 770, 894, 1020, 1147, 1268, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1402, 1508, 1636, 1764, 1275, 1275, 1880, 1275, 1275, 1275, 1275, 1275, 1275, 2008, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 32, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 2114, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275, 1275 }; const short upper_data[2242]= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 743, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, 0, -32, -32, -32, -32, -32, -32, -32, 121, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -232, 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, -1, -300, 0, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 0, 0, -1, 0, 0, 97, 0, 0, 0, -1, 0, 0, 0, 0, 130, 0, 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 56, 0, 0, 0, 0, 0, -1, -2, 0, -1, -2, 0, -1, -2, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, -79, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, 0, -1, -2, 0, -1, 0, 0, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, 0, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -210, -206, 0, -205, -205, 0, -202, 0, -203, 0, 0, 0, 0, -205, 0, 0, -207, 0, 0, 0, 0, -209, -211, 0, 0, 0, 0, 0, -211, 0, 0, -213, 0, 0, -214, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -218, 0, 0, -218, 0, 0, 0, 0, -218, 0, -217, -217, 0, 0, 0, 0, 0, 0, -219, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -38, -37, -37, -37, 0, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -31, -32, -32, -32, -32, -32, -32, -32, -32, -32, -64, -63, -63, 0, -62, -57, 0, 0, 0, -47, -54, 0, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, -86, -80, 7, 0, 0, -96, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, -80, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, -48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, 0, 0, 0, 0, -59, 0, 0, 0, 0, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 8, 0, 8, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 74, 74, 86, 86, 86, 86, 100, 100, 128, 128, 112, 112, 126, 126, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -7205, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -26, -26, -26, -26, -26, -26, -26, -26, -26, -26, -26, -26, -26, -26, -26, -26, -26, -26, -26, -26, -26, -26, -26, -26, -26, -26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; const unsigned short lower_plane[68]= { 0, 74, 74, 76, 203, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 7 }; const unsigned short lower_block[331]= { 0, 91, 219, 346, 466, 517, 517, 639, 767, 893, 1021, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 1149, 1255, 1376, 1496, 517, 517, 1621, 517, 517, 517, 517, 517, 517, 1733, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 1828, 517, 517, 517, 517, 517, 517, 517, 517, 1956, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517 }; const short lower_data[2084]= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 0, 32, 32, 32, 32, 32, 32, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, -199, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, -121, 1, 0, 1, 0, 1, 0, 0, 210, 1, 0, 1, 0, 206, 1, 0, 205, 205, 1, 0, 0, 79, 202, 203, 1, 0, 205, 207, 0, 211, 209, 1, 0, 0, 0, 211, 213, 0, 214, 1, 0, 1, 0, 1, 0, 218, 1, 0, 218, 0, 0, 1, 0, 218, 1, 0, 217, 217, 1, 0, 1, 0, 219, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 2, 1, 0, 1, 0, -97, -56, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, -130, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 38, 0, 37, 37, 37, 0, 64, 0, 63, 63, 0, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 0, 32, 32, 32, 32, 32, 32, 32, 32, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, -60, 0, 0, 1, 0, -7, 1, 0, 0, 0, 0, 0, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -8, -8, -8, -8, -8, -8, 0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -8, -8, -8, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -8, -8, -8, -8, -8, -8, 0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -8, -8, -8, -8, -8, -8, 0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -8, -8, -8, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -8, 0, -8, 0, -8, 0, -8, 0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -8, -8, -8, -8, -8, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -8, -8, -8, -8, -8, -8, 0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -8, -8, -8, -8, -8, -8, 0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -8, -8, -8, -8, -8, -8, 0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -74, -74, -9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -86, -86, -86, -86, -9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -100, -100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -8, -8, -112, -112, -7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -128, -128, -126, -126, -9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -7517, 0, 0, 0, -8383, -8262, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; const std::ctype_base::mask digit = std::ctype_base::digit; const std::ctype_base::mask xdigit = std::ctype_base::xdigit; const std::ctype_base::mask cntrl = std::ctype_base::cntrl; const std::ctype_base::mask space = std::ctype_base::space; const std::ctype_base::mask upper = std::ctype_base::upper; const std::ctype_base::mask lower = std::ctype_base::lower; const std::ctype_base::mask alpha = std::ctype_base::alpha; const std::ctype_base::mask punct = std::ctype_base::punct; const std::ctype_base::mask print = std::ctype_base::print; const std::ctype_base::mask alnum = std::ctype_base::alnum; const std::ctype_base::mask graph = std::ctype_base::graph; const std::ctype_base::mask ctype_data[13936]= { std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|space) & ~(print)), std::ctype_base::mask((cntrl|space) & ~(print)), std::ctype_base::mask((cntrl|space) & ~(print)), std::ctype_base::mask((cntrl|space) & ~(print)), std::ctype_base::mask((cntrl|space) & ~(print)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper|xdigit) & ~(digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper|xdigit) & ~(digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper|xdigit) & ~(digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper|xdigit) & ~(digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper|xdigit) & ~(digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper|xdigit) & ~(digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower|xdigit) & ~(digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower|xdigit) & ~(digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower|xdigit) & ~(digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower|xdigit) & ~(digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower|xdigit) & ~(digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower|xdigit) & ~(digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower|xdigit) & ~(digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower|xdigit) & ~(digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower|xdigit) & ~(digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower|xdigit) & ~(digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower|xdigit) & ~(digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|upper) & ~(xdigit|digit|lower|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|print|punct) & ~(xdigit|digit|upper|lower|alpha|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha|lower) & ~(xdigit|digit|upper|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|digit|xdigit) & ~(upper|lower|alpha|space|punct)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((graph|alnum|print|alpha) & ~(xdigit|digit|upper|lower|punct|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl|print|space) & ~(xdigit|digit|upper|lower|punct|alpha)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask((cntrl) & ~(xdigit|digit|upper|lower|punct|alpha|space)), std::ctype_base::mask(0) }; } uint32_t tolower(uint32_t ucs) { return ucs + lower_data[lower_block[lower_plane[ucs>>14]+((ucs>>7)&127)]+(ucs&127)]; } uint32_t toupper(uint32_t ucs) { return ucs + upper_data[upper_block[upper_plane[ucs>>14]+((ucs>>7)&127)]+(ucs&127)]; } std::ctype_base::mask ctypeMask(uint32_t ch) { return ctype_data[ ctype_lookup2[ ctype_lookup1[ch>>14]+((ch>>7)&127) ]+(ch&127) ]; } } // namespace zim libzim-2.0.0/src/unicode.h000066400000000000000000000041511312444564200153730ustar00rootroot00000000000000/* * Copyright (C) 2008 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include namespace zim { uint32_t tolower(uint32_t ucs); uint32_t toupper(uint32_t ucs); std::ctype_base::mask ctypeMask(uint32_t ch); inline bool isalpha(uint32_t ch) { return ctypeMask(ch) & std::ctype_base::alpha; } inline bool isalnum(uint32_t ch) { return ctypeMask(ch) & std::ctype_base::alnum; } inline bool ispunct(uint32_t ch) { return ctypeMask(ch) & std::ctype_base::punct; } inline bool iscntrl(uint32_t ch) { return ctypeMask(ch) & std::ctype_base::cntrl; } inline bool isdigit(uint32_t ch) { return ctypeMask(ch) & std::ctype_base::digit; } inline bool isxdigit(uint32_t ch) { return ctypeMask(ch) & std::ctype_base::xdigit; } inline bool isgraph(uint32_t ch) { return ctypeMask(ch) & std::ctype_base::graph; } inline bool islower(uint32_t ch) { return ctypeMask(ch) & std::ctype_base::lower; } inline bool isupper(uint32_t ch) { return ctypeMask(ch) & std::ctype_base::upper; } inline bool isprint(uint32_t ch) { return ctypeMask(ch) & std::ctype_base::print; } inline bool isspace(uint32_t ch) { return ctypeMask(ch) & std::ctype_base::space; } } libzim-2.0.0/src/unlzmastream.cpp000066400000000000000000000115461312444564200170300ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * */ #include "unlzmastream.h" #include #include "log.h" #include "config.h" #include #include #include "envvalue.h" log_define("zim.lzma.uncompress") namespace zim { namespace { lzma_ret checkError(lzma_ret ret) { if (ret != LZMA_OK && ret != LZMA_STREAM_END) { std::ostringstream msg; msg << "inflate-error " << ret; switch (ret) { case LZMA_OK: msg << ": LZMA_OK"; break; case LZMA_STREAM_END: msg << ": LZMA_STREAM_END"; break; case LZMA_NO_CHECK: msg << ": LZMA_NO_CHECK"; break; case LZMA_UNSUPPORTED_CHECK: msg << ": LZMA_UNSUPPORTED_CHECK"; break; case LZMA_GET_CHECK: msg << ": LZMA_GET_CHECK"; break; case LZMA_MEM_ERROR: msg << ": LZMA_MEM_ERROR"; break; case LZMA_MEMLIMIT_ERROR: msg << ": LZMA_MEMLIMIT_ERROR"; break; case LZMA_FORMAT_ERROR: msg << ": LZMA_FORMAT_ERROR"; break; case LZMA_OPTIONS_ERROR: msg << ": LZMA_OPTIONS_ERROR"; break; case LZMA_DATA_ERROR: msg << ": LZMA_DATA_ERROR"; break; case LZMA_BUF_ERROR: msg << ": LZMA_BUF_ERROR"; break; case LZMA_PROG_ERROR: msg << ": LZMA_PROG_ERROR"; break; } log_error(msg); throw UnlzmaError(ret, msg.str()); } return ret; } } UnlzmaStreamBuf::UnlzmaStreamBuf(std::streambuf* sinksource_, unsigned bufsize_) : iobuffer(new char_type[bufsize_]), bufsize(bufsize_), sinksource(sinksource_) { std::memset(reinterpret_cast(&stream), 0, sizeof(stream)); unsigned memsize = envMemSize("ZIM_LZMA_MEMORY_SIZE", LZMA_MEMORY_SIZE * 1024 * 1024); checkError( ::lzma_stream_decoder(&stream, memsize, 0)); } UnlzmaStreamBuf::~UnlzmaStreamBuf() { ::lzma_end(&stream); delete[] iobuffer; } UnlzmaStreamBuf::int_type UnlzmaStreamBuf::overflow(int_type c) { if (pptr()) { // initialize input-stream for stream.next_in = reinterpret_cast(obuffer()); stream.avail_in = pptr() - pbase(); lzma_ret ret; do { // initialize ibuffer stream.next_out = reinterpret_cast(ibuffer()); stream.avail_out = ibuffer_size(); ret = ::lzma_code(&stream, LZMA_RUN); checkError(ret); // copy zbuffer to sinksource std::streamsize count = ibuffer_size() - stream.avail_out; std::streamsize n = sinksource->sputn(reinterpret_cast(ibuffer()), count); if (n < count) return traits_type::eof(); } while (ret != LZMA_STREAM_END && stream.avail_in > 0); } // reset outbuffer setp(obuffer(), obuffer() + obuffer_size()); if (c != traits_type::eof()) sputc(traits_type::to_char_type(c)); return 0; } UnlzmaStreamBuf::int_type UnlzmaStreamBuf::underflow() { // read from sinksource and decompress into obuffer stream.next_out = reinterpret_cast(obuffer()); stream.avail_out = obuffer_size(); do { // fill ibuffer first if needed if (stream.avail_in == 0) { if (sinksource->in_avail() > 0) { // there is data already available // read compressed data from source into ibuffer stream.avail_in = sinksource->sgetn(ibuffer(), std::min(sinksource->in_avail(), ibuffer_size())); } else { // no data available stream.avail_in = sinksource->sgetn(ibuffer(), ibuffer_size()); if (stream.avail_in == 0) return traits_type::eof(); } stream.next_in = (const uint8_t*)ibuffer(); } // we decompress it now into obuffer // at least one character received from source - pass to decompressor checkError(::lzma_code(&stream, LZMA_RUN)); setg(obuffer(), obuffer(), obuffer() + obuffer_size() - stream.avail_out); } while (gptr() == egptr()); return sgetc(); } int UnlzmaStreamBuf::sync() { if (pptr() && overflow(traits_type::eof()) == traits_type::eof()) return -1; return 0; } } libzim-2.0.0/src/unlzmastream.h000066400000000000000000000055261312444564200164760ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef ZIM_UNLZMASTREAM_H #define ZIM_UNLZMASTREAM_H #include #include #include namespace zim { class UnlzmaError : public std::runtime_error { lzma_ret ret; public: UnlzmaError(lzma_ret ret_, const std::string& msg) : std::runtime_error(msg), ret(ret_) { } lzma_ret getRetcode() const { return ret; } }; class UnlzmaStreamBuf : public std::streambuf { lzma_stream stream; char_type* iobuffer; unsigned bufsize; std::streambuf* sinksource; char_type* ibuffer() { return iobuffer; } std::streamsize ibuffer_size() { return bufsize >> 1; } char_type* obuffer() { return iobuffer + ibuffer_size(); } std::streamsize obuffer_size() { return bufsize >> 1; } public: explicit UnlzmaStreamBuf(std::streambuf* sinksource_, unsigned bufsize = 8192); ~UnlzmaStreamBuf(); /// see std::streambuf int_type overflow(int_type c); /// see std::streambuf int_type underflow(); /// see std::streambuf int sync(); void setSinksource(std::streambuf* sinksource_) { sinksource = sinksource_; } }; class UnlzmaStream : public std::iostream { UnlzmaStreamBuf streambuf; public: explicit UnlzmaStream(std::streambuf* sinksource, unsigned bufsize = 8192) : std::iostream(0), streambuf(sinksource, bufsize) { init(&streambuf); } explicit UnlzmaStream(std::ios& sinksource, unsigned bufsize = 8192) : std::iostream(0), streambuf(sinksource.rdbuf(), bufsize) { init(&streambuf); } void setSinksource(std::streambuf* sinksource) { streambuf.setSinksource(sinksource); } void setSinksource(std::ios& sinksource) { streambuf.setSinksource(sinksource.rdbuf()); } void setSink(std::ostream& sink) { streambuf.setSinksource(sink.rdbuf()); } void setSource(std::istream& source) { streambuf.setSinksource(source.rdbuf()); } }; } #endif // ZIM_UNLZMASTREAM_H libzim-2.0.0/src/uuid.cpp000066400000000000000000000045141312444564200152510ustar00rootroot00000000000000/* * Copyright (C) 2009 Tommi Maekitalo * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and * NON-INFRINGEMENT. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #include #include // necessary to have the new types #include "log.h" #include "md5stream.h" #ifdef _WIN32 # include # include int gettimeofday(struct timeval* tp, void* tzp) { DWORD t; t = timeGetTime(); tp->tv_sec = t / 1000; tp->tv_usec = t % 1000; return 0; } #define getpid GetCurrentProcessId #else # include #endif log_define("zim.uuid") namespace zim { namespace { char hex[] = "0123456789abcdef"; inline char hi(char v) { return hex[(v >> 4) & 0xf]; } inline char lo(char v) { return hex[v & 0xf]; } } Uuid Uuid::generate() { Uuid ret; struct timeval tv; gettimeofday(&tv, 0); Md5stream m; clock_t c = clock(); m << c << tv.tv_sec << tv.tv_usec; m.getDigest(reinterpret_cast(&ret.data[0])); log_debug("generated uuid: " << ret.data); return ret; } std::ostream& operator<< (std::ostream& out, const Uuid& uuid) { for (unsigned n = 0; n < 4; ++n) out << hi(uuid.data[n]) << lo(uuid.data[n]); out << '-'; for (unsigned n = 4; n < 6; ++n) out << hi(uuid.data[n]) << lo(uuid.data[n]); out << '-'; for (unsigned n = 6; n < 8; ++n) out << hi(uuid.data[n]) << lo(uuid.data[n]); out << '-'; for (unsigned n = 8; n < 10; ++n) out << hi(uuid.data[n]) << lo(uuid.data[n]); out << '-'; for (unsigned n = 10; n < 16; ++n) out << hi(uuid.data[n]) << lo(uuid.data[n]); return out; } } libzim-2.0.0/src/xapian/000077500000000000000000000000001312444564200150535ustar00rootroot00000000000000libzim-2.0.0/src/xapian/htmlparse.cc000066400000000000000000000233211312444564200173620ustar00rootroot00000000000000/* htmlparse.cc: simple HTML parser for omega indexer * * Copyright 1999,2000,2001 BrightStation PLC * Copyright 2001 Ananova Ltd * Copyright 2002,2006,2007,2008 Olly Betts * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 * USA */ // #include #include "htmlparse.h" #include // #include "utf8convert.h" #include #include #include #include #include using namespace std; inline void lowercase_string(string &str) { for (string::iterator i = str.begin(); i != str.end(); ++i) { *i = tolower(static_cast(*i)); } } map zim::HtmlParser::named_ents; inline static bool p_notdigit(char c) { return !isdigit(static_cast(c)); } inline static bool p_notxdigit(char c) { return !isxdigit(static_cast(c)); } inline static bool p_notalnum(char c) { return !isalnum(static_cast(c)); } inline static bool p_notwhitespace(char c) { return !isspace(static_cast(c)); } inline static bool p_nottag(char c) { return !isalnum(static_cast(c)) && c != '.' && c != '-' && c != ':'; // ':' for XML namespaces. } inline static bool p_whitespacegt(char c) { return isspace(static_cast(c)) || c == '>'; } inline static bool p_whitespaceeqgt(char c) { return isspace(static_cast(c)) || c == '=' || c == '>'; } bool zim::HtmlParser::get_parameter(const string & param, string & value) { map::const_iterator i = parameters.find(param); if (i == parameters.end()) return false; value = i->second; return true; } zim::HtmlParser::HtmlParser() { static const struct ent { const char *n; unsigned int v; } ents[] = { #include "namedentities.h" { NULL, 0 } }; if (named_ents.empty()) { const struct ent *i = ents; while (i->n) { named_ents[string(i->n)] = i->v; ++i; } } } void zim::HtmlParser::decode_entities(string &s) { // We need a const_iterator version of s.end() - otherwise the // find() and find_if() templates don't work... string::const_iterator amp = s.begin(), s_end = s.end(); while ((amp = find(amp, s_end, '&')) != s_end) { unsigned int val = 0; string::const_iterator end, p = amp + 1; if (p != s_end && *p == '#') { p++; if (p != s_end && (*p == 'x' || *p == 'X')) { // hex p++; end = find_if(p, s_end, p_notxdigit); sscanf(s.substr(p - s.begin(), end - p).c_str(), "%x", &val); } else { // number end = find_if(p, s_end, p_notdigit); val = atoi(s.substr(p - s.begin(), end - p).c_str()); } } else { end = find_if(p, s_end, p_notalnum); string code = s.substr(p - s.begin(), end - p); map::const_iterator i; i = named_ents.find(code); if (i != named_ents.end()) val = i->second; } if (end < s_end && *end == ';') end++; if (val) { string::size_type amp_pos = amp - s.begin(); if (val < 0x80) { s.replace(amp_pos, end - amp, 1u, char(val)); } else { // Convert unicode value val to UTF-8. char seq[4]; unsigned len = Xapian::Unicode::nonascii_to_utf8(val, seq); s.replace(amp_pos, end - amp, seq, len); } s_end = s.end(); // We've modified the string, so the iterators are no longer // valid... amp = s.begin() + amp_pos + 1; } else { amp = end; } } } void zim::HtmlParser::parse_html(const string &body) { in_script = false; parameters.clear(); string::const_iterator start = body.begin(); while (true) { // Skip through until we find an HTML tag, a comment, or the end of // document. Ignore isolated occurrences of `<' which don't start // a tag or comment. string::const_iterator p = start; while (true) { p = find(p, body.end(), '<'); if (p == body.end()) break; unsigned char ch = *(p + 1); // Tag, closing tag, or comment (or SGML declaration). if ((!in_script && isalpha(ch)) || ch == '/' || ch == '!') break; if (ch == '?') { // PHP code or XML declaration. // XML declaration is only valid at the start of the first line. // FIXME: need to deal with BOMs... if (p != body.begin() || body.size() < 20) break; // XML declaration looks something like this: // if (p[2] != 'x' || p[3] != 'm' || p[4] != 'l') break; if (strchr(" \t\r\n", p[5]) == NULL) break; string::const_iterator decl_end = find(p + 6, body.end(), '?'); if (decl_end == body.end()) break; // Default charset for XML is UTF-8. charset = "UTF-8"; string decl(p + 6, decl_end); size_t enc = decl.find("encoding"); if (enc == string::npos) break; enc = decl.find_first_not_of(" \t\r\n", enc + 8); if (enc == string::npos || enc == decl.size()) break; if (decl[enc] != '=') break; enc = decl.find_first_not_of(" \t\r\n", enc + 1); if (enc == string::npos || enc == decl.size()) break; if (decl[enc] != '"' && decl[enc] != '\'') break; char quote = decl[enc++]; size_t enc_end = decl.find(quote, enc); if (enc != string::npos) charset = decl.substr(enc, enc_end - enc); break; } p++; } // Process text up to start of tag. if (p > start) { string text = body.substr(start - body.begin(), p - start); // convert_to_utf8(text, charset); decode_entities(text); process_text(text); } if (p == body.end()) break; start = p + 1; if (start == body.end()) break; if (*start == '!') { if (++start == body.end()) break; if (++start == body.end()) break; // comment or SGML declaration if (*(start - 1) == '-' && *start == '-') { ++start; string::const_iterator close = find(start, body.end(), '>'); // An unterminated comment swallows rest of document // (like Netscape, but unlike MSIE IIRC) if (close == body.end()) break; p = close; // look for --> while (p != body.end() && (*(p - 1) != '-' || *(p - 2) != '-')) p = find(p + 1, body.end(), '>'); if (p != body.end()) { // Check for htdig's "ignore this bit" comments. if (p - start == 15 && string(start, p - 2) == "htdig_noindex") { string::size_type i; i = body.find("", p + 1 - body.begin()); if (i == string::npos) break; start = body.begin() + i + 21; continue; } // If we found --> skip to there. start = p; } else { // Otherwise skip to the first > we found (as Netscape does). start = close; } } else { // just an SGML declaration, perhaps giving the DTD - ignore it start = find(start - 1, body.end(), '>'); if (start == body.end()) break; } ++start; } else if (*start == '?') { if (++start == body.end()) break; // PHP - swallow until ?> or EOF start = find(start + 1, body.end(), '>'); // look for ?> while (start != body.end() && *(start - 1) != '?') start = find(start + 1, body.end(), '>'); // unterminated PHP swallows rest of document (rather arbitrarily // but it avoids polluting the database when things go wrong) if (start != body.end()) ++start; } else { // opening or closing tag int closing = 0; if (*start == '/') { closing = 1; start = find_if(start + 1, body.end(), p_notwhitespace); } p = start; start = find_if(start, body.end(), p_nottag); string tag = body.substr(p - body.begin(), start - p); // convert tagname to lowercase lowercase_string(tag); if (closing) { closing_tag(tag); if (in_script && tag == "script") in_script = false; /* ignore any bogus parameters on closing tags */ p = find(start, body.end(), '>'); if (p == body.end()) break; start = p + 1; } else { // FIXME: parse parameters lazily. while (start < body.end() && *start != '>') { string name, value; p = find_if(start, body.end(), p_whitespaceeqgt); name.assign(body, start - body.begin(), p - start); p = find_if(p, body.end(), p_notwhitespace); start = p; if (start != body.end() && *start == '=') { start = find_if(start + 1, body.end(), p_notwhitespace); p = body.end(); int quote = *start; if (quote == '"' || quote == '\'') { start++; p = find(start, body.end(), quote); } if (p == body.end()) { // unquoted or no closing quote p = find_if(start, body.end(), p_whitespacegt); } value.assign(body, start - body.begin(), p - start); start = find_if(p, body.end(), p_notwhitespace); if (!name.empty()) { // convert parameter name to lowercase lowercase_string(name); // in case of multiple entries, use the first // (as Netscape does) parameters.insert(make_pair(name, value)); } } } #if 0 cout << "<" << tag; map::const_iterator x; for (x = parameters.begin(); x != parameters.end(); x++) { cout << " " << x->first << "=\"" << x->second << "\""; } cout << ">\n"; #endif opening_tag(tag); parameters.clear(); // In