--- /dev/null
+Subject: Update embedded BitMagic to version 6.4.0 (from 6.0.0).
+Description: Notably address new "inlining failed in call to
+ 'always_inline'" errors on mips*el. (The bmagic package currently has
+ version 6.3.0, slightly predating the necessary fix.)
+Author: Aaron M. Ucko <ucko@debian.org>
+Forwarded: yes
+Last-Updated: 2020-09-20
+Index: c++/include/util/bitset/bmsparsevec_compr.h
+===================================================================
+--- a/c++/include/util/bitset/bmsparsevec_compr.h (revision 90103)
++++ b/c++/include/util/bitset/bmsparsevec_compr.h (revision 90104)
+@@ -98,19 +98,121 @@
+ class reference
+ {
+ public:
+- reference(rsc_sparse_vector<Val, SV>& csv, size_type idx) BMNOEXEPT
++ reference(rsc_sparse_vector<Val, SV>& csv, size_type idx) BMNOEXCEPT
+ : csv_(csv), idx_(idx)
+ {}
+- operator value_type() const { return csv_.get(idx_); }
+- bool operator==(const reference& ref) const
++ operator value_type() const BMNOEXCEPT { return csv_.get(idx_); }
++ bool operator==(const reference& ref) const BMNOEXCEPT
+ { return bool(*this) == bool(ref); }
+- bool is_null() const { return csv_.is_null(idx_); }
++ bool is_null() const BMNOEXCEPT { return csv_.is_null(idx_); }
+ private:
+ rsc_sparse_vector<Val, SV>& csv_;
+ size_type idx_;
+ };
+
++ /**
++ Const iterator to traverse the rsc sparse vector.
+
++ Implementation uses buffer for decoding so, competing changes
++ to the original vector may not match the iterator returned values.
++
++ This iterator keeps an operational buffer, memory footprint is not
++ negligable
++
++ @ingroup sv
++ */
++ class const_iterator
++ {
++ public:
++ friend class rsc_sparse_vector;
++
++#ifndef BM_NO_STL
++ typedef std::input_iterator_tag iterator_category;
++#endif
++ typedef rsc_sparse_vector<Val, SV> rsc_sparse_vector_type;
++ typedef rsc_sparse_vector_type* rsc_sparse_vector_type_ptr;
++ typedef typename rsc_sparse_vector_type::value_type value_type;
++ typedef typename rsc_sparse_vector_type::size_type size_type;
++ typedef typename rsc_sparse_vector_type::bvector_type bvector_type;
++ typedef typename bvector_type::allocator_type allocator_type;
++ typedef typename
++ bvector_type::allocator_type::allocator_pool_type allocator_pool_type;
++ typedef bm::byte_buffer<allocator_type> buffer_type;
++
++ typedef unsigned difference_type;
++ typedef unsigned* pointer;
++ typedef value_type& reference;
++
++ public:
++ const_iterator() BMNOEXCEPT;
++ const_iterator(const rsc_sparse_vector_type* csv) BMNOEXCEPT;
++ const_iterator(const rsc_sparse_vector_type* csv, size_type pos) BMNOEXCEPT;
++ const_iterator(const const_iterator& it) BMNOEXCEPT;
++
++ bool operator==(const const_iterator& it) const BMNOEXCEPT
++ { return (pos_ == it.pos_) && (csv_ == it.csv_); }
++ bool operator!=(const const_iterator& it) const BMNOEXCEPT
++ { return ! operator==(it); }
++ bool operator < (const const_iterator& it) const BMNOEXCEPT
++ { return pos_ < it.pos_; }
++ bool operator <= (const const_iterator& it) const BMNOEXCEPT
++ { return pos_ <= it.pos_; }
++ bool operator > (const const_iterator& it) const BMNOEXCEPT
++ { return pos_ > it.pos_; }
++ bool operator >= (const const_iterator& it) const BMNOEXCEPT
++ { return pos_ >= it.pos_; }
++
++ /// \brief Get current position (value)
++ value_type operator*() const { return this->value(); }
++
++
++ /// \brief Advance to the next available value
++ const_iterator& operator++() BMNOEXCEPT { this->advance(); return *this; }
++
++ /// \brief Advance to the next available value
++ const_iterator& operator++(int)
++ { const_iterator tmp(*this);this->advance(); return tmp; }
++
++
++ /// \brief Get current position (value)
++ value_type value() const;
++
++ /// \brief Get NULL status
++ bool is_null() const BMNOEXCEPT;
++
++ /// Returns true if iterator is at a valid position
++ bool valid() const BMNOEXCEPT { return pos_ != bm::id_max; }
++
++ /// Invalidate current iterator
++ void invalidate() BMNOEXCEPT { pos_ = bm::id_max; }
++
++ /// Current position (index) in the vector
++ size_type pos() const BMNOEXCEPT{ return pos_; }
++
++ /// re-position to a specified position
++ void go_to(size_type pos) BMNOEXCEPT;
++
++ /// advance iterator forward by one
++ /// @return true if it is still valid
++ bool advance() BMNOEXCEPT;
++
++ void skip_zero_values() BMNOEXCEPT;
++ private:
++ enum buf_size_e
++ {
++ n_buf_size = 1024 * 8
++ };
++
++ private:
++ const rsc_sparse_vector_type* csv_; ///!< ptr to parent
++ size_type pos_; ///!< Position
++ mutable buffer_type vbuffer_; ///!< value buffer
++ mutable buffer_type tbuffer_; ///!< temp buffer
++ mutable value_type* buf_ptr_; ///!< position in the buffer
++ };
++
++
++
+ /**
+ Back insert iterator implements buffered insert, faster than generic
+ access assignment.
+@@ -141,8 +243,8 @@
+ typedef void reference;
+
+ public:
+- back_insert_iterator();
+- back_insert_iterator(rsc_sparse_vector_type* csv);
++ back_insert_iterator() BMNOEXCEPT;
++ back_insert_iterator(rsc_sparse_vector_type* csv) BMNOEXCEPT;
+
+ back_insert_iterator& operator=(const back_insert_iterator& bi)
+ {
+@@ -154,7 +256,8 @@
+ ~back_insert_iterator();
+
+ /** push value to the vector */
+- back_insert_iterator& operator=(value_type v) { this->add(v); return *this; }
++ back_insert_iterator& operator=(value_type v)
++ { this->add(v); return *this; }
+ /** noop */
+ back_insert_iterator& operator*() { return *this; }
+ /** noop */
+@@ -166,10 +269,10 @@
+ void add(value_type v);
+
+ /** add NULL (no-value) to the container */
+- void add_null();
++ void add_null() BMNOEXCEPT;
+
+ /** add a series of consequitve NULLs (no-value) to the container */
+- void add_null(size_type count);
++ void add_null(size_type count) BMNOEXCEPT;
+
+ /** flush the accumulated buffer */
+ void flush();
+@@ -183,7 +286,8 @@
+ ///size_type add_value(value_type v);
+
+ typedef rsc_sparse_vector_type::sparse_vector_type sparse_vector_type;
+- typedef typename sparse_vector_type::back_insert_iterator sparse_vector_bi;
++ typedef
++ typename sparse_vector_type::back_insert_iterator sparse_vector_bi;
+ private:
+ rsc_sparse_vector_type* csv_; ///!< pointer on the parent vector
+ sparse_vector_bi sv_bi_;
+@@ -192,6 +296,7 @@
+ public:
+ // ------------------------------------------------------------
+ /*! @name Construction and assignment */
++
+ //@{
+
+ rsc_sparse_vector(bm::null_support null_able = bm::use_null,
+@@ -198,6 +303,18 @@
+ allocation_policy_type ap = allocation_policy_type(),
+ size_type bv_max_size = bm::id_max,
+ const allocator_type& alloc = allocator_type());
++
++ /**
++ Contructor to pre-initialize the list of assigned (not NULL) elements.
++
++ If the list of not NULL elements is known upfront it can help to
++ pre-declare it, enable rank-select index and then use set function.
++ This scenario gives significant speed boost, comparing random assignment
++
++ @param bv_null - not NULL vector for the container
++ */
++ rsc_sparse_vector(const bvector_type& bv_null);
++
+ ~rsc_sparse_vector();
+
+ /*! copy-ctor */
+@@ -205,7 +322,7 @@
+
+
+ /*! copy assignmment operator */
+- rsc_sparse_vector<Val,SV>& operator = (const rsc_sparse_vector<Val, SV>& csv)
++ rsc_sparse_vector<Val,SV>& operator=(const rsc_sparse_vector<Val, SV>& csv)
+ {
+ if (this != &csv)
+ {
+@@ -219,13 +336,13 @@
+ }
+ return *this;
+ }
+-
++
+ #ifndef BM_NO_CXX11
+ /*! move-ctor */
+- rsc_sparse_vector(rsc_sparse_vector<Val,SV>&& csv) BMNOEXEPT;
++ rsc_sparse_vector(rsc_sparse_vector<Val,SV>&& csv) BMNOEXCEPT;
+
+ /*! move assignmment operator */
+- rsc_sparse_vector<Val,SV>& operator=(rsc_sparse_vector<Val,SV>&& csv) BMNOEXEPT
++ rsc_sparse_vector<Val,SV>& operator=(rsc_sparse_vector<Val,SV>&& csv) BMNOEXCEPT
+ {
+ if (this != &csv)
+ {
+@@ -249,7 +366,7 @@
+ /*! \brief return size of the vector
+ \return size of sparse vector
+ */
+- size_type size() const;
++ size_type size() const BMNOEXCEPT;
+
+ /*! \brief return true if vector is empty
+ \return true if empty
+@@ -281,7 +398,7 @@
+ \param idx - element index
+ \return value of the element
+ */
+- value_type get(size_type idx) const;
++ value_type get(size_type idx) const BMNOEXCEPT;
+
+ /*!
+ \brief set specified element with bounds checking and automatic resize
+@@ -301,7 +418,30 @@
+ */
+ void set(size_type idx, value_type v);
+
++
+ /*!
++ \brief increment specified element by one
++ \param idx - element index
++ */
++ void inc(size_type idx);
++
++ /*!
++ \brief increment specified element by one
++ \param idx - element index
++ \param v - increment value
++ */
++ void inc(size_type idx, value_type v);
++
++ /*!
++ \brief increment specified element by one, element MUST be NOT NULL
++ Faster than just inc() if element is NULL - behavior is undefined
++ \param idx - element index
++ \param v - increment value
++ @sa inc
++ */
++ void inc_not_null(size_type idx, value_type v);
++
++ /*!
+ \brief set specified element to NULL
+ RSC vector actually erases element when it is set to NULL (expensive).
+ \param idx - element index
+@@ -309,18 +449,17 @@
+ void set_null(size_type idx);
+
+
+-
+ /** \brief test if specified element is NULL
+ \param idx - element index
+ \return true if it is NULL false if it was assigned or container
+ is not configured to support assignment flags
+ */
+- bool is_null(size_type idx) const;
++ bool is_null(size_type idx) const BMNOEXCEPT;
+
+ /**
+ \brief Get bit-vector of assigned values (or NULL)
+ */
+- const bvector_type* get_null_bvector() const;
++ const bvector_type* get_null_bvector() const BMNOEXCEPT;
+
+ /**
+ \brief find position of compressed element by its rank
+@@ -327,7 +466,7 @@
+ \param rank - rank (virtual index in sparse vector)
+ \param idx - index (true position)
+ */
+- bool find_rank(size_type rank, size_type& idx) const;
++ bool find_rank(size_type rank, size_type& idx) const BMNOEXCEPT;
+
+ //@}
+
+@@ -334,12 +473,43 @@
+ // ------------------------------------------------------------
+ /*! @name Export content to C-stype array */
+ ///@{
+-
++
++ /**
++ \brief C-style decode
++ \param arr - decode target array (must be properly sized)
++ \param idx_from - start address to decode
++ \param size - number of elements to decode
++ \param zero_mem - flag if array needs to beset to zeros first
++
++ @return actual decoded size
++ @sa decode_buf
++ */
+ size_type decode(value_type* arr,
+ size_type idx_from,
+ size_type size,
+ bool zero_mem = true) const;
+
++
++ /**
++ \brief C-style decode (variant with external memory)
++ Analog of decode, but requires two arrays.
++ Faster than decode in many cases.
++
++ \param arr - decode target array (must be properly sized)
++ \param arr_buf_tmp - decode temp bufer (must be same size of arr)
++ \param idx_from - start address to decode
++ \param size - number of elements to decode
++ \param zero_mem - flag if array needs to beset to zeros first
++
++ @return actual decoded size
++ @sa decode
++ */
++ size_type decode_buf(value_type* arr,
++ value_type* arr_buf_tmp,
++ size_type idx_from,
++ size_type size,
++ bool zero_mem = true) const BMNOEXCEPT;
++
+ ///@}
+
+
+@@ -367,7 +537,7 @@
+ \brief check if another vector has the same content
+ \return true, if it is the same
+ */
+- bool equal(const rsc_sparse_vector<Val, SV>& csv) const;
++ bool equal(const rsc_sparse_vector<Val, SV>& csv) const BMNOEXCEPT;
+ //@}
+
+
+@@ -395,6 +565,20 @@
+ /*! @name Iterator access */
+ //@{
+
++ /** Provide const iterator access to container content */
++ const_iterator begin() const BMNOEXCEPT
++ { return const_iterator(this); }
++
++ /** Provide const iterator access to the end */
++ const_iterator end() const BMNOEXCEPT
++ { return const_iterator(this, bm::id_max); }
++
++ /** Get const_itertor re-positioned to specific element
++ @param idx - position in the sparse vector
++ */
++ const_iterator get_const_iterator(size_type idx) const BMNOEXCEPT
++ { return const_iterator(this, idx); }
++
+ back_insert_iterator get_back_inserter() { return back_insert_iterator(this); }
+ ///@}
+
+@@ -408,13 +592,14 @@
+ \param opt_mode - requested compression depth
+ \param stat - memory allocation statistics after optimization
+ */
+- void optimize(bm::word_t* temp_block = 0,
+- typename bvector_type::optmode opt_mode = bvector_type::opt_compress,
+- statistics* stat = 0);
++ void optimize(
++ bm::word_t* temp_block = 0,
++ typename bvector_type::optmode opt_mode = bvector_type::opt_compress,
++ statistics* stat = 0);
+
+ /*! \brief resize to zero, free memory
+ */
+- void clear() BMNOEXEPT;
++ void clear() BMNOEXCEPT;
+
+ /*!
+ @brief Calculates memory statistics.
+@@ -427,7 +612,8 @@
+
+ @sa statistics
+ */
+- void calc_stat(struct rsc_sparse_vector<Val, SV>::statistics* st) const;
++ void calc_stat(
++ struct rsc_sparse_vector<Val, SV>::statistics* st) const BMNOEXCEPT;
+
+ ///@}
+
+@@ -448,6 +634,14 @@
+ void copy_range(const rsc_sparse_vector<Val, SV>& csv,
+ size_type left, size_type right);
+
++ /**
++ @brief merge two vectors (argument gets destroyed)
++ It is important that both vectors have the same NULL vectors
++ @param csv - [in,out] argumnet vector to merge
++ (works like move so arg should not be used after the merge)
++ */
++ void merge_not_null(rsc_sparse_vector<Val, SV>& csv);
++
+ ///@}
+
+ // ------------------------------------------------------------
+@@ -467,12 +661,12 @@
+ /*!
+ \brief returns true if prefix sum table is in sync with the vector
+ */
+- bool in_sync() const { return in_sync_; }
++ bool in_sync() const BMNOEXCEPT { return in_sync_; }
+
+ /*!
+ \brief Unsync the prefix sum table
+ */
+- void unsync() { in_sync_ = false; }
++ void unsync() BMNOEXCEPT { in_sync_ = false; }
+ ///@}
+
+ // ------------------------------------------------------------
+@@ -483,19 +677,23 @@
+ \brief get access to bit-plain, function checks and creates a plain
+ \return bit-vector for the bit plain
+ */
+- bvector_type_const_ptr get_plain(unsigned i) const { return sv_.get_plain(i); }
++ bvector_type_const_ptr get_plain(unsigned i) const BMNOEXCEPT
++ { return sv_.get_plain(i); }
+
+- bvector_type_ptr get_plain(unsigned i) { return sv_.get_plain(i); }
++ bvector_type_ptr get_plain(unsigned i) BMNOEXCEPT
++ { return sv_.get_plain(i); }
+
+ /*!
+ Number of effective bit-plains in the value type
+ */
+- unsigned effective_plains() const { return sv_.effective_plains(); }
++ unsigned effective_plains() const BMNOEXCEPT
++ { return sv_.effective_plains(); }
+
+ /*!
+ \brief get total number of bit-plains in the vector
+ */
+- static unsigned plains() { return sparse_vector_type::plains(); }
++ static unsigned plains() BMNOEXCEPT
++ { return sparse_vector_type::plains(); }
+
+ /** Number of stored bit-plains (value plains + extra */
+ static unsigned stored_plains()
+@@ -504,22 +702,23 @@
+ /*!
+ \brief access dense vector
+ */
+- const sparse_vector_type& get_sv() const { return sv_; }
++ const sparse_vector_type& get_sv() const BMNOEXCEPT { return sv_; }
+
+ /*!
+ \brief size of internal dense vector
+ */
+- size_type effective_size() const { return sv_.size(); }
++ size_type effective_size() const BMNOEXCEPT { return sv_.size(); }
+
+ /**
+ \brief Always 1 (non-matrix type)
+ */
+- size_type effective_vector_max() const { return 1; }
++ size_type effective_vector_max() const BMNOEXCEPT { return 1; }
+
+ /*!
+ get read-only access to inetrnal bit-matrix
+ */
+- const bmatrix_type& get_bmatrix() const { return sv_.get_bmatrix(); }
++ const bmatrix_type& get_bmatrix() const BMNOEXCEPT
++ { return sv_.get_bmatrix(); }
+
+ ///@}
+
+@@ -537,27 +736,30 @@
+
+ \return true if id is known and resolved successfully
+ */
+- bool resolve(size_type idx, size_type* idx_to) const;
++ bool resolve(size_type idx, size_type* idx_to) const BMNOEXCEPT;
+
+ bool resolve_range(size_type from, size_type to,
+- size_type* idx_from, size_type* idx_to) const;
++ size_type* idx_from, size_type* idx_to) const BMNOEXCEPT;
+
+ void resize_internal(size_type sz) { sv_.resize_internal(sz); }
+- size_type size_internal() const { return sv_.size(); }
++ size_type size_internal() const BMNOEXCEPT { return sv_.size(); }
+
+- bool is_remap() const { return false; }
+- size_t remap_size() const { return 0; }
+- const unsigned char* get_remap_buffer() const { return 0; }
+- unsigned char* init_remap_buffer() { return 0; }
+- void set_remap() { }
++ bool is_remap() const BMNOEXCEPT { return false; }
++ size_t remap_size() const BMNOEXCEPT { return 0; }
++ const unsigned char* get_remap_buffer() const BMNOEXCEPT { return 0; }
++ unsigned char* init_remap_buffer() BMNOEXCEPT { return 0; }
++ void set_remap() BMNOEXCEPT { }
+
+ void push_back_no_check(size_type idx, value_type v);
+
+
+ private:
+- void construct_bv_blocks();
+- void free_bv_blocks();
+
++ /// Allocate memory for RS index
++ void construct_rs_index();
++ /// Free rs-index
++ void free_rs_index();
++
+ protected:
+ template<class SVect> friend class sparse_vector_scanner;
+ template<class SVect> friend class sparse_vector_serializer;
+@@ -580,21 +782,45 @@
+ allocation_policy_type ap,
+ size_type bv_max_size,
+ const allocator_type& alloc)
+-: sv_(null_able, ap, bv_max_size, alloc),
+- in_sync_(false)
++: sv_(null_able, ap, bv_max_size, alloc), in_sync_(false)
+ {
+ BM_ASSERT(null_able == bm::use_null);
+ BM_ASSERT(int(sv_value_plains) == int(SV::sv_value_plains));
+ size_ = max_id_ = 0;
+- construct_bv_blocks();
++ construct_rs_index();
+ }
+
+ //---------------------------------------------------------------------
+
+ template<class Val, class SV>
++rsc_sparse_vector<Val, SV>::rsc_sparse_vector(const bvector_type& bv_null)
++: sv_(bm::use_null), in_sync_(false)
++{
++ construct_rs_index();
++ bvector_type* bv = sv_.get_null_bvect();
++ BM_ASSERT(bv);
++ *bv = bv_null;
++
++ bool found = bv->find_reverse(max_id_);
++ if (found)
++ {
++ size_ = max_id_ + 1;
++ size_type sz = bv->count();
++ sv_.resize(sz);
++ }
++ else
++ {
++ BM_ASSERT(!bv->any());
++ size_ = max_id_ = 0;
++ }
++}
++
++//---------------------------------------------------------------------
++
++template<class Val, class SV>
+ rsc_sparse_vector<Val, SV>::~rsc_sparse_vector()
+ {
+- free_bv_blocks();
++ free_rs_index();
+ }
+
+ //---------------------------------------------------------------------
+@@ -602,24 +828,20 @@
+ template<class Val, class SV>
+ rsc_sparse_vector<Val, SV>::rsc_sparse_vector(
+ const rsc_sparse_vector<Val, SV>& csv)
+-: sv_(csv.sv_),
+- size_(csv.size_),
+- max_id_(csv.max_id_),
+- in_sync_(csv.in_sync_)
++: sv_(csv.sv_), size_(csv.size_), max_id_(csv.max_id_), in_sync_(csv.in_sync_)
+ {
+ BM_ASSERT(int(sv_value_plains) == int(SV::sv_value_plains));
+
+- construct_bv_blocks();
++ construct_rs_index();
+ if (in_sync_)
+- {
+ bv_blocks_ptr_->copy_from(*(csv.bv_blocks_ptr_));
+- }
+ }
+
+ //---------------------------------------------------------------------
+
+ template<class Val, class SV>
+-rsc_sparse_vector<Val, SV>::rsc_sparse_vector(rsc_sparse_vector<Val,SV>&& csv) BMNOEXEPT
++rsc_sparse_vector<Val, SV>::rsc_sparse_vector(
++ rsc_sparse_vector<Val,SV>&& csv) BMNOEXCEPT
+ : sv_(bm::use_null),
+ size_(0),
+ max_id_(0), in_sync_(false)
+@@ -636,7 +858,7 @@
+
+ template<class Val, class SV>
+ typename rsc_sparse_vector<Val, SV>::size_type
+-rsc_sparse_vector<Val, SV>::size() const
++rsc_sparse_vector<Val, SV>::size() const BMNOEXCEPT
+ {
+ return size_;
+ }
+@@ -686,6 +908,7 @@
+ size_type sv_idx = bv_null->count_range(0, idx);
+ bv_null->clear_bit_no_check(idx);
+ sv_.erase(--sv_idx);
++ in_sync_ = false;
+ }
+ }
+
+@@ -692,19 +915,102 @@
+ //---------------------------------------------------------------------
+
+ template<class Val, class SV>
++void rsc_sparse_vector<Val, SV>::inc(size_type idx)
++{
++ bvector_type* bv_null = sv_.get_null_bvect();
++ BM_ASSERT(bv_null);
++
++ size_type sv_idx;
++ bool found = bv_null->test(idx);
++
++ sv_idx = in_sync_ ? bv_null->count_to(idx, *bv_blocks_ptr_)
++ : bv_null->count_range(0, idx); // TODO: make test'n'count
++
++ if (found)
++ {
++ sv_.inc_no_null(--sv_idx);
++ }
++ else
++ {
++ sv_.insert_value_no_null(sv_idx, 1);
++ bv_null->set_bit_no_check(idx);
++
++ if (idx > max_id_)
++ {
++ max_id_ = idx;
++ size_ = max_id_ + 1;
++ }
++ in_sync_ = false;
++ }
++}
++
++//---------------------------------------------------------------------
++
++template<class Val, class SV>
++void rsc_sparse_vector<Val, SV>::inc(size_type idx, value_type v)
++{
++ bvector_type* bv_null = sv_.get_null_bvect();
++ BM_ASSERT(bv_null);
++
++ size_type sv_idx;
++ bool found = bv_null->test(idx);
++
++ sv_idx = in_sync_ ? bv_null->count_to(idx, *bv_blocks_ptr_)
++ : bv_null->count_range(0, idx); // TODO: make test'n'count
++
++ if (found)
++ {
++ sv_.inc_no_null(--sv_idx, v);
++ }
++ else
++ {
++ sv_.insert_value_no_null(sv_idx, v);
++ bv_null->set_bit_no_check(idx);
++
++ if (idx > max_id_)
++ {
++ max_id_ = idx;
++ size_ = max_id_ + 1;
++ }
++ in_sync_ = false;
++ }
++}
++
++//---------------------------------------------------------------------
++
++template<class Val, class SV>
++void rsc_sparse_vector<Val, SV>::inc_not_null(size_type idx, value_type v)
++{
++ bvector_type* bv_null = sv_.get_null_bvect();
++ BM_ASSERT(bv_null->test(idx)); // idx must be NOT NULL
++
++ size_type sv_idx;
++ sv_idx = in_sync_ ? bv_null->count_to(idx, *bv_blocks_ptr_)
++ : bv_null->count_range(0, idx); // TODO: make test'n'count
++ --sv_idx;
++ if (v == 1)
++ sv_.inc_no_null(sv_idx);
++ else
++ sv_.inc_no_null(sv_idx, v);
++}
++
++
++//---------------------------------------------------------------------
++
++template<class Val, class SV>
+ void rsc_sparse_vector<Val, SV>::set(size_type idx, value_type v)
+ {
+ bvector_type* bv_null = sv_.get_null_bvect();
+ BM_ASSERT(bv_null);
+-
++
++ size_type sv_idx;
+ bool found = bv_null->test(idx);
+- size_type sv_idx = bv_null->count_range(0, idx); // TODO: make test'n'count
+-// size_type sv_idx;
+-// bool found = resolve(idx, &sv_idx);
+
++ sv_idx = in_sync_ ? bv_null->count_to(idx, *bv_blocks_ptr_)
++ : bv_null->count_range(0, idx); // TODO: make test'n'count
++
+ if (found)
+ {
+- //sv_.set(--sv_idx, v);
+ sv_.set_value_no_null(--sv_idx, v);
+ }
+ else
+@@ -725,7 +1031,7 @@
+
+ template<class Val, class SV>
+ bool rsc_sparse_vector<Val, SV>::equal(
+- const rsc_sparse_vector<Val, SV>& csv) const
++ const rsc_sparse_vector<Val, SV>& csv) const BMNOEXCEPT
+ {
+ if (this == &csv)
+ return true;
+@@ -739,7 +1045,7 @@
+
+ template<class Val, class SV>
+ void rsc_sparse_vector<Val, SV>::load_from(
+- const sparse_vector_type& sv_src)
++ const sparse_vector_type& sv_src)
+ {
+ max_id_ = size_ = 0;
+
+@@ -837,10 +1143,10 @@
+ //---------------------------------------------------------------------
+
+ template<class Val, class SV>
+-bool rsc_sparse_vector<Val, SV>::resolve(size_type idx, size_type* idx_to) const
++bool rsc_sparse_vector<Val, SV>::resolve(size_type idx,
++ size_type* idx_to) const BMNOEXCEPT
+ {
+ BM_ASSERT(idx_to);
+-
+ const bvector_type* bv_null = sv_.get_null_bvector();
+ if (in_sync_)
+ {
+@@ -849,23 +1155,17 @@
+ else // slow access
+ {
+ bool found = bv_null->test(idx);
+- if (!found)
+- {
+- *idx_to = 0;
+- }
+- else
+- {
+- *idx_to = bv_null->count_range(0, idx);
+- }
++ *idx_to = found ? bv_null->count_range(0, idx) : 0;
+ }
+ return bool(*idx_to);
+ }
++
+ //---------------------------------------------------------------------
+
+ template<class Val, class SV>
+ bool rsc_sparse_vector<Val, SV>::resolve_range(
+ size_type from, size_type to,
+- size_type* idx_from, size_type* idx_to) const
++ size_type* idx_from, size_type* idx_to) const BMNOEXCEPT
+ {
+ BM_ASSERT(idx_to && idx_from);
+ const bvector_type* bv_null = sv_.get_null_bvector();
+@@ -876,12 +1176,15 @@
+ copy_sz = bv_null->count_range(from, to);
+ if (!copy_sz)
+ return false;
++
+ if (in_sync_)
+- sv_left = bv_null->count_range(0, from, *bv_blocks_ptr_);
++ sv_left = bv_null->rank_corrected(from, *bv_blocks_ptr_);
+ else
++ {
+ sv_left = bv_null->count_range(0, from);
+- bool tl = bv_null->test(from); // TODO: add count and test
+- sv_left -= tl; // rank correction
++ bool tl = bv_null->test(from); // TODO: add count and test
++ sv_left -= tl; // rank correction
++ }
+
+ *idx_from = sv_left; *idx_to = sv_left + copy_sz - 1;
+ return true;
+@@ -910,7 +1213,7 @@
+
+ template<class Val, class SV>
+ typename rsc_sparse_vector<Val, SV>::value_type
+-rsc_sparse_vector<Val, SV>::get(size_type idx) const
++rsc_sparse_vector<Val, SV>::get(size_type idx) const BMNOEXCEPT
+ {
+ size_type sv_idx;
+ bool found = resolve(idx, &sv_idx);
+@@ -923,7 +1226,7 @@
+ //---------------------------------------------------------------------
+
+ template<class Val, class SV>
+-bool rsc_sparse_vector<Val, SV>::is_null(size_type idx) const
++bool rsc_sparse_vector<Val, SV>::is_null(size_type idx) const BMNOEXCEPT
+ {
+ const bvector_type* bv_null = sv_.get_null_bvector();
+ BM_ASSERT(bv_null);
+@@ -950,7 +1253,7 @@
+ //---------------------------------------------------------------------
+
+ template<class Val, class SV>
+-void rsc_sparse_vector<Val, SV>::clear() BMNOEXEPT
++void rsc_sparse_vector<Val, SV>::clear() BMNOEXCEPT
+ {
+ sv_.clear();
+ in_sync_ = false; max_id_ = size_ = 0;
+@@ -960,7 +1263,7 @@
+
+ template<class Val, class SV>
+ void rsc_sparse_vector<Val, SV>::calc_stat(
+- struct rsc_sparse_vector<Val, SV>::statistics* st) const
++ struct rsc_sparse_vector<Val, SV>::statistics* st) const BMNOEXCEPT
+ {
+ BM_ASSERT(st);
+ sv_.calc_stat((typename sparse_vector_type::statistics*)st);
+@@ -977,7 +1280,7 @@
+
+ template<class Val, class SV>
+ const typename rsc_sparse_vector<Val, SV>::bvector_type*
+-rsc_sparse_vector<Val, SV>::get_null_bvector() const
++rsc_sparse_vector<Val, SV>::get_null_bvector() const BMNOEXCEPT
+ {
+ return sv_.get_null_bvector();
+ }
+@@ -986,7 +1289,8 @@
+
+ template<class Val, class SV>
+ bool
+-rsc_sparse_vector<Val, SV>::find_rank(size_type rank, size_type& idx) const
++rsc_sparse_vector<Val, SV>::find_rank(size_type rank,
++ size_type& idx) const BMNOEXCEPT
+ {
+ BM_ASSERT(rank);
+ bool b;
+@@ -1006,7 +1310,7 @@
+ rsc_sparse_vector<Val, SV>::decode(value_type* arr,
+ size_type idx_from,
+ size_type size,
+- bool /*zero_mem*/) const
++ bool zero_mem) const
+ {
+ if (size == 0)
+ return 0;
+@@ -1020,51 +1324,104 @@
+
+ if ((bm::id_max - size) <= idx_from)
+ size = bm::id_max - idx_from;
++ if ((idx_from + size) > this->size())
++ size = this->size() - idx_from;
+
+ const bvector_type* bv_null = sv_.get_null_bvector();
++ size_type rank = bv_null->rank_corrected(idx_from, *bv_blocks_ptr_);
+
+- size_type rank = bv_null->count_to(idx_from, *bv_blocks_ptr_);
+- bool b = bv_null->test(idx_from);
+-
++ BM_ASSERT(rank == bv_null->count_range(0, idx_from) - bv_null->test(idx_from));
++
+ bvector_enumerator_type en_i = bv_null->get_enumerator(idx_from);
+- size_type i = *en_i;
+- if (idx_from + size <= i) // empty space (all zeros)
++ BM_ASSERT(en_i.valid());
++
++ if (zero_mem)
++ ::memset(arr, 0, sizeof(value_type)*size);
++
++ sparse_vector_const_iterator it = sv_.get_const_iterator(rank);
++ size_type i = 0;
++ if (it.valid())
+ {
++ do
++ {
++ size_type en_idx = *en_i;
++ size_type delta = en_idx - idx_from;
++ idx_from += delta;
++ i += delta;
++ if (i >= size)
++ return size;
++ arr[i++] = it.value();
++ if (!en_i.advance())
++ break;
++ if (!it.advance())
++ break;
++ ++idx_from;
++ } while (i < size);
++ }
++ return i;
++}
++
++
++template<class Val, class SV>
++typename rsc_sparse_vector<Val, SV>::size_type
++rsc_sparse_vector<Val, SV>::decode_buf(value_type* arr,
++ value_type* arr_buf_tmp,
++ size_type idx_from,
++ size_type size,
++ bool zero_mem) const BMNOEXCEPT
++{
++ if (!size || (idx_from >= this->size()))
++ return 0;
++
++ BM_ASSERT(arr && arr_buf_tmp);
++ BM_ASSERT(arr != arr_buf_tmp);
++ BM_ASSERT(in_sync_); // call sync() before decoding
++ BM_ASSERT(bv_blocks_ptr_);
++
++ if ((bm::id_max - size) <= idx_from)
++ size = bm::id_max - idx_from;
++ if ((idx_from + size) > this->size())
++ size = this->size() - idx_from;
++
++ if (zero_mem)
+ ::memset(arr, 0, sizeof(value_type)*size);
++
++ const bvector_type* bv_null = sv_.get_null_bvector();
++ size_type rank = bv_null->rank_corrected(idx_from, *bv_blocks_ptr_);
++
++ BM_ASSERT(rank == bv_null->count_range(0, idx_from) - bv_null->test(idx_from));
++
++ bvector_enumerator_type en_i = bv_null->get_enumerator(idx_from);
++ if (!en_i.valid())
+ return size;
+- }
+- rank -= b;
+- sparse_vector_const_iterator it = sv_.get_const_iterator(rank);
+- i = 0;
+- while (it.valid())
++
++ size_type i = en_i.value();
++ if (idx_from + size <= i) // empty space (all zeros)
++ return size;
++
++ size_type extract_cnt =
++ bv_null->count_range(idx_from, idx_from + size - 1, *bv_blocks_ptr_);
++
++ BM_ASSERT(extract_cnt <= this->size());
++ auto ex_sz = sv_.decode(arr_buf_tmp, rank, extract_cnt, true);
++ BM_ASSERT(ex_sz == extract_cnt); (void) ex_sz;
++
++ for (i = 0; i < extract_cnt; ++i)
+ {
+- if (!en_i.valid())
+- break;
++ BM_ASSERT(en_i.valid());
+ size_type en_idx = *en_i;
+- while (idx_from < en_idx) // zero the empty prefix
+- {
+- arr[i] ^= arr[i];
+- ++i; ++idx_from;
+- if (i == size)
+- return i;
+- }
+- BM_ASSERT(idx_from == en_idx);
+- arr[i] = *it;
+- ++i; ++idx_from;
+- if (i == size)
+- return i;
+-
++ arr[en_idx-idx_from] = arr_buf_tmp[i];
+ en_i.advance();
+- it.advance();
+- } // while
+-
+- return i;
++ } // for i
++
++ return size;
+ }
+
++
+ //---------------------------------------------------------------------
+
+ template<class Val, class SV>
+-void rsc_sparse_vector<Val, SV>::construct_bv_blocks()
++void rsc_sparse_vector<Val, SV>::construct_rs_index()
+ {
+ if (bv_blocks_ptr_)
+ return;
+@@ -1076,7 +1433,7 @@
+ //---------------------------------------------------------------------
+
+ template<class Val, class SV>
+-void rsc_sparse_vector<Val, SV>::free_bv_blocks()
++void rsc_sparse_vector<Val, SV>::free_rs_index()
+ {
+ if (bv_blocks_ptr_)
+ {
+@@ -1086,12 +1443,56 @@
+ }
+
+ //---------------------------------------------------------------------
++
++template<class Val, class SV>
++void rsc_sparse_vector<Val, SV>::copy_range(
++ const rsc_sparse_vector<Val, SV>& csv,
++ size_type left, size_type right)
++{
++ if (left > right)
++ bm::xor_swap(left, right);
++
++ if (left >= csv.size())
++ return;
++
++ size_ = csv.size_; max_id_ = csv.max_id_;
++ in_sync_ = false;
++
++ const bvector_type* arg_bv_null = csv.sv_.get_null_bvector();
++ size_type sv_left, sv_right;
++ bool range_valid = csv.resolve_range(left, right, &sv_left, &sv_right);
++ if (!range_valid)
++ {
++ sv_.clear(); sv_.resize(size_);
++ bvector_type* bv_null = sv_.get_null_bvect();
++ bv_null->copy_range(*arg_bv_null, 0, right);
++ return;
++ }
++ bvector_type* bv_null = sv_.get_null_bvect();
++ bv_null->copy_range(*arg_bv_null, 0, right); // not NULL vector gets a full copy
++ sv_.copy_range(csv.sv_, sv_left, sv_right, bm::no_null); // don't copy NULL
++}
++
++
++//---------------------------------------------------------------------
++
++template<class Val, class SV>
++void rsc_sparse_vector<Val, SV>::merge_not_null(rsc_sparse_vector<Val, SV>& csv)
++{
++ // MUST have the same NULL to work
++ BM_ASSERT(sv_.get_null_bvector()->equal(*csv.sv_.get_null_bvector()));
++
++ sv_.merge(csv.sv_);
++}
++
++
++//---------------------------------------------------------------------
+ //
+ //---------------------------------------------------------------------
+
+
+ template<class Val, class SV>
+-rsc_sparse_vector<Val, SV>::back_insert_iterator::back_insert_iterator()
++rsc_sparse_vector<Val, SV>::back_insert_iterator::back_insert_iterator() BMNOEXCEPT
+ : csv_(0)
+ {}
+
+@@ -1100,7 +1501,7 @@
+
+ template<class Val, class SV>
+ rsc_sparse_vector<Val, SV>::back_insert_iterator::back_insert_iterator
+- (rsc_sparse_vector_type* csv)
++ (rsc_sparse_vector_type* csv) BMNOEXCEPT
+ {
+ csv_ = csv;
+ sv_bi_ = csv->sv_.get_back_inserter();
+@@ -1134,7 +1535,7 @@
+ //---------------------------------------------------------------------
+
+ template<class Val, class SV>
+-void rsc_sparse_vector<Val, SV>::back_insert_iterator::add_null()
++void rsc_sparse_vector<Val, SV>::back_insert_iterator::add_null() BMNOEXCEPT
+ {
+ BM_ASSERT(csv_);
+ csv_->max_id_++;
+@@ -1145,7 +1546,7 @@
+
+ template<class Val, class SV>
+ void rsc_sparse_vector<Val, SV>::back_insert_iterator::add_null(
+- rsc_sparse_vector<Val, SV>::back_insert_iterator::size_type count)
++ rsc_sparse_vector<Val, SV>::back_insert_iterator::size_type count) BMNOEXCEPT
+ {
+ BM_ASSERT(csv_);
+ csv_->max_id_+=count;
+@@ -1162,39 +1563,140 @@
+ }
+
+ //---------------------------------------------------------------------
++//
++//---------------------------------------------------------------------
+
++template<class Val, class BV>
++rsc_sparse_vector<Val, BV>::const_iterator::const_iterator() BMNOEXCEPT
++: csv_(0), pos_(bm::id_max), buf_ptr_(0)
++{}
++
++//---------------------------------------------------------------------
++
+ template<class Val, class SV>
+-void rsc_sparse_vector<Val, SV>::copy_range(
+- const rsc_sparse_vector<Val, SV>& csv,
+- size_type left, size_type right)
++rsc_sparse_vector<Val, SV>::const_iterator::const_iterator(
++ const typename rsc_sparse_vector<Val, SV>::const_iterator& it) BMNOEXCEPT
++: csv_(it.csv_), pos_(it.pos_), buf_ptr_(0)
++{}
++
++//---------------------------------------------------------------------
++
++template<class Val, class SV>
++rsc_sparse_vector<Val, SV>::const_iterator::const_iterator(
++ const typename rsc_sparse_vector<Val, SV>::const_iterator::rsc_sparse_vector_type* csv
++ ) BMNOEXCEPT
++: csv_(csv), buf_ptr_(0)
+ {
+- if (left > right)
+- bm::xor_swap(left, right);
++ BM_ASSERT(csv_);
++ pos_ = csv_->empty() ? bm::id_max : 0u;
++}
+
+- if (left >= csv.size())
+- return;
+-
+- size_ = csv.size_; max_id_ = csv.max_id_;
+- in_sync_ = false;
++//---------------------------------------------------------------------
+
+- const bvector_type* arg_bv_null = csv.sv_.get_null_bvector();
+- size_type sv_left, sv_right;
+- bool range_valid = csv.resolve_range(left, right, &sv_left, &sv_right);
++template<class Val, class SV>
++rsc_sparse_vector<Val, SV>::const_iterator::const_iterator(
++ const typename rsc_sparse_vector<Val, SV>::const_iterator::rsc_sparse_vector_type* csv,
++ typename rsc_sparse_vector<Val, SV>::size_type pos) BMNOEXCEPT
++: csv_(csv), buf_ptr_(0)
++{
++ BM_ASSERT(csv_);
++ this->go_to(pos);
++}
+
+- if (!range_valid)
++//---------------------------------------------------------------------
++
++template<class Val, class SV>
++void rsc_sparse_vector<Val, SV>::const_iterator::go_to(size_type pos) BMNOEXCEPT
++{
++ pos_ = (!csv_ || pos >= csv_->size()) ? bm::id_max : pos;
++ buf_ptr_ = 0;
++}
++
++//---------------------------------------------------------------------
++
++template<class Val, class SV>
++bool rsc_sparse_vector<Val, SV>::const_iterator::advance() BMNOEXCEPT
++{
++ if (pos_ == bm::id_max) // nothing to do, we are at the end
++ return false;
++ ++pos_;
++ if (pos_ >= csv_->size())
+ {
+- sv_.clear();
+- sv_.resize(size_);
+- bvector_type* bv_null = sv_.get_null_bvect();
+- bv_null->copy_range(*arg_bv_null, 0, right);
+- return;
++ this->invalidate();
++ return false;
+ }
+- bvector_type* bv_null = sv_.get_null_bvect();
+- bv_null->copy_range(*arg_bv_null, 0, right); // not NULL vector gets a full copy
+- sv_.copy_range(csv.sv_, sv_left, sv_right, bm::no_null); // don't copy NULL
++ if (buf_ptr_)
++ {
++ ++buf_ptr_;
++ if (buf_ptr_ - ((value_type*)vbuffer_.data()) >= n_buf_size)
++ buf_ptr_ = 0;
++ }
++ return true;
+ }
+
++//---------------------------------------------------------------------
+
++template<class Val, class SV>
++typename rsc_sparse_vector<Val, SV>::const_iterator::value_type
++rsc_sparse_vector<Val, SV>::const_iterator::value() const
++{
++ BM_ASSERT(this->valid());
++ value_type v;
++
++ if (!buf_ptr_)
++ {
++ vbuffer_.reserve(n_buf_size * sizeof(value_type));
++ tbuffer_.reserve(n_buf_size * sizeof(value_type));
++ buf_ptr_ = (value_type*)(vbuffer_.data());
++ value_type* tmp_buf_ptr = (value_type*) (tbuffer_.data());
++
++ csv_->decode_buf(buf_ptr_, tmp_buf_ptr, pos_, n_buf_size, true);
++ }
++ v = *buf_ptr_;
++ return v;
++}
++
++//---------------------------------------------------------------------
++
++template<class Val, class SV>
++void rsc_sparse_vector<Val, SV>::const_iterator::skip_zero_values() BMNOEXCEPT
++{
++ value_type v = value();
++ if (buf_ptr_)
++ {
++ v = *buf_ptr_;
++ value_type* buf_end = ((value_type*)vbuffer_.data()) + n_buf_size;
++ while(!v)
++ {
++ ++pos_;
++ if (++buf_ptr_ < buf_end)
++ v = *buf_ptr_;
++ else
++ break;
++ }
++ if (pos_ >= csv_->size())
++ {
++ pos_ = bm::id_max;
++ return;
++ }
++ if (buf_ptr_ >= buf_end)
++ buf_ptr_ = 0;
++ }
++}
++
++//---------------------------------------------------------------------
++
++template<class Val, class SV>
++bool rsc_sparse_vector<Val, SV>::const_iterator::is_null() const BMNOEXCEPT
++{
++ return csv_->is_null(pos_);
++}
++
++
++//---------------------------------------------------------------------
++
++
++
+ } // namespace bm
+
+ #include "bmundef.h"
+Index: c++/include/util/bitset/bmsparsevec.h
+===================================================================
+--- a/c++/include/util/bitset/bmsparsevec.h (revision 90103)
++++ b/c++/include/util/bitset/bmsparsevec.h (revision 90104)
+@@ -37,7 +37,7 @@
+
+
+ #include "bmtrans.h"
+-#include "bmalgo.h"
++#include "bmalgo_impl.h"
+ #include "bmbuffer.h"
+ #include "bmbmatrix.h"
+ #include "bmdef.h"
+@@ -113,10 +113,10 @@
+ class reference
+ {
+ public:
+- reference(sparse_vector<Val, BV>& sv, size_type idx) BMNOEXEPT
++ reference(sparse_vector<Val, BV>& sv, size_type idx) BMNOEXCEPT
+ : sv_(sv), idx_(idx)
+ {}
+- operator value_type() const { return sv_.get(idx_); }
++ operator value_type() const BMNOEXCEPT { return sv_.get(idx_); }
+ reference& operator=(const reference& ref)
+ {
+ sv_.set(idx_, (value_type)ref);
+@@ -127,9 +127,9 @@
+ sv_.set(idx_, val);
+ return *this;
+ }
+- bool operator==(const reference& ref) const
++ bool operator==(const reference& ref) const BMNOEXCEPT
+ { return bool(*this) == bool(ref); }
+- bool is_null() const { return sv_.is_null(idx_); }
++ bool is_null() const BMNOEXCEPT { return sv_.is_null(idx_); }
+ private:
+ sparse_vector<Val, BV>& sv_;
+ size_type idx_;
+@@ -169,30 +169,30 @@
+ typedef value_type& reference;
+
+ public:
+- const_iterator();
+- const_iterator(const sparse_vector_type* sv);
+- const_iterator(const sparse_vector_type* sv, size_type pos);
+- const_iterator(const const_iterator& it);
++ const_iterator() BMNOEXCEPT;
++ const_iterator(const sparse_vector_type* sv) BMNOEXCEPT;
++ const_iterator(const sparse_vector_type* sv, size_type pos) BMNOEXCEPT;
++ const_iterator(const const_iterator& it) BMNOEXCEPT;
+
+- bool operator==(const const_iterator& it) const
++ bool operator==(const const_iterator& it) const BMNOEXCEPT
+ { return (pos_ == it.pos_) && (sv_ == it.sv_); }
+- bool operator!=(const const_iterator& it) const
++ bool operator!=(const const_iterator& it) const BMNOEXCEPT
+ { return ! operator==(it); }
+- bool operator < (const const_iterator& it) const
++ bool operator < (const const_iterator& it) const BMNOEXCEPT
+ { return pos_ < it.pos_; }
+- bool operator <= (const const_iterator& it) const
++ bool operator <= (const const_iterator& it) const BMNOEXCEPT
+ { return pos_ <= it.pos_; }
+- bool operator > (const const_iterator& it) const
++ bool operator > (const const_iterator& it) const BMNOEXCEPT
+ { return pos_ > it.pos_; }
+- bool operator >= (const const_iterator& it) const
++ bool operator >= (const const_iterator& it) const BMNOEXCEPT
+ { return pos_ >= it.pos_; }
+
+ /// \brief Get current position (value)
+- value_type operator*() const { return this->value(); }
++ value_type operator*() const { return this->value(); }
+
+
+ /// \brief Advance to the next available value
+- const_iterator& operator++() { this->advance(); return *this; }
++ const_iterator& operator++() BMNOEXCEPT { this->advance(); return *this; }
+
+ /// \brief Advance to the next available value
+ const_iterator& operator++(int)
+@@ -203,24 +203,25 @@
+ value_type value() const;
+
+ /// \brief Get NULL status
+- bool is_null() const;
++ bool is_null() const BMNOEXCEPT;
+
+ /// Returns true if iterator is at a valid position
+- bool valid() const { return pos_ != bm::id_max; }
++ bool valid() const BMNOEXCEPT { return pos_ != bm::id_max; }
+
+ /// Invalidate current iterator
+- void invalidate() { pos_ = bm::id_max; }
++ void invalidate() BMNOEXCEPT { pos_ = bm::id_max; }
+
+ /// Current position (index) in the vector
+- size_type pos() const { return pos_; }
++ size_type pos() const BMNOEXCEPT{ return pos_; }
+
+ /// re-position to a specified position
+- void go_to(size_type pos);
++ void go_to(size_type pos) BMNOEXCEPT;
+
+ /// advance iterator forward by one
+- void advance();
++ /// @return true if it is still valid
++ bool advance() BMNOEXCEPT;
+
+- void skip_zero_values();
++ void skip_zero_values() BMNOEXCEPT;
+ private:
+ enum buf_size_e
+ {
+@@ -232,7 +233,6 @@
+ size_type pos_; ///!< Position
+ mutable buffer_type buffer_; ///!< value buffer
+ mutable value_type* buf_ptr_; ///!< position in the buffer
+- mutable allocator_pool_type pool_;
+ };
+
+ /**
+@@ -313,7 +313,7 @@
+ Get access to not-null vector
+ @internal
+ */
+- bvector_type* get_null_bvect() const { return bv_null_; }
++ bvector_type* get_null_bvect() const BMNOEXCEPT { return bv_null_; }
+
+ /** add value to the buffer without changing the NULL vector
+ @param v - value to push back
+@@ -323,9 +323,9 @@
+ size_type add_value_no_null(value_type v);
+
+ /**
+- Reconf back inserter not to touch the NULL vector
++ Reconfшпгку back inserter not to touch the NULL vector
+ */
+- void disable_set_null() { set_not_null_ = false; }
++ void disable_set_null() BMNOEXCEPT { set_not_null_ = false; }
+ // ---------------------------------------------------------------
+
+ protected:
+@@ -387,11 +387,11 @@
+
+ #ifndef BM_NO_CXX11
+ /*! move-ctor */
+- sparse_vector(sparse_vector<Val, BV>&& sv) BMNOEXEPT;
++ sparse_vector(sparse_vector<Val, BV>&& sv) BMNOEXCEPT;
+
+
+ /*! move assignmment operator */
+- sparse_vector<Val,BV>& operator = (sparse_vector<Val, BV>&& sv) BMNOEXEPT
++ sparse_vector<Val,BV>& operator = (sparse_vector<Val, BV>&& sv) BMNOEXCEPT
+ {
+ if (this != &sv)
+ {
+@@ -402,7 +402,7 @@
+ }
+ #endif
+
+- ~sparse_vector() BMNOEXEPT;
++ ~sparse_vector() BMNOEXCEPT;
+ ///@}
+
+
+@@ -411,7 +411,8 @@
+ ///@{
+
+ /** \brief Operator to get write access to an element */
+- reference operator[](size_type idx) { return reference(*this, idx); }
++ reference operator[](size_type idx) BMNOEXCEPT
++ { return reference(*this, idx); }
+
+ /*!
+ \brief get specified element without bounds checking
+@@ -418,7 +419,8 @@
+ \param idx - element index
+ \return value of the element
+ */
+- value_type operator[](size_type idx) const { return this->get(idx); }
++ value_type operator[](size_type idx) const BMNOEXCEPT
++ { return this->get(idx); }
+
+ /*!
+ \brief access specified element with bounds checking
+@@ -431,7 +433,7 @@
+ \param idx - element index
+ \return value of the element
+ */
+- value_type get(size_type idx) const;
++ value_type get(size_type idx) const BMNOEXCEPT;
+
+ /*!
+ \brief set specified element with bounds checking and automatic resize
+@@ -485,21 +487,24 @@
+ //@{
+
+ /** Provide const iterator access to container content */
+- const_iterator begin() const;
++ const_iterator begin() const BMNOEXCEPT;
+
+ /** Provide const iterator access to the end */
+- const_iterator end() const { return const_iterator(this, bm::id_max); }
++ const_iterator end() const BMNOEXCEPT
++ { return const_iterator(this, bm::id_max); }
+
+ /** Get const_itertor re-positioned to specific element
+ @param idx - position in the sparse vector
+ */
+- const_iterator get_const_iterator(size_type idx) const { return const_iterator(this, idx); }
++ const_iterator get_const_iterator(size_type idx) const BMNOEXCEPT
++ { return const_iterator(this, idx); }
+
+ /** Provide back insert iterator
+ Back insert iterator implements buffered insertion,
+ which is faster, than random access or push_back
+ */
+- back_insert_iterator get_back_inserter() { return back_insert_iterator(this); }
++ back_insert_iterator get_back_inserter()
++ { return back_insert_iterator(this); }
+ ///@}
+
+
+@@ -515,7 +520,7 @@
+ /** \brief trait if sparse vector is "compressed" (false)
+ */
+ static
+- bool is_compressed() { return false; }
++ bool is_compressed() BMNOEXCEPT { return false; }
+
+ ///@}
+
+@@ -608,7 +613,7 @@
+
+ /*! \brief content exchange
+ */
+- void swap(sparse_vector<Val, BV>& sv) BMNOEXEPT;
++ void swap(sparse_vector<Val, BV>& sv) BMNOEXCEPT;
+
+ // ------------------------------------------------------------
+ /*! @name Clear */
+@@ -615,7 +620,7 @@
+ ///@{
+
+ /*! \brief resize to zero, free memory */
+- void clear() BMNOEXEPT;
++ void clear() BMNOEXCEPT;
+
+ /*!
+ \brief clear range (assign bit 0 for all plains)
+@@ -636,12 +641,12 @@
+ /*! \brief return size of the vector
+ \return size of sparse vector
+ */
+- size_type size() const { return this->size_; }
++ size_type size() const BMNOEXCEPT { return this->size_; }
+
+ /*! \brief return true if vector is empty
+ \return true if empty
+ */
+- bool empty() const { return (size() == 0); }
++ bool empty() const BMNOEXCEPT { return (size() == 0); }
+
+ /*! \brief resize vector
+ \param sz - new size
+@@ -663,7 +668,7 @@
+ \return true, if it is the same
+ */
+ bool equal(const sparse_vector<Val, BV>& sv,
+- bm::null_support null_able = bm::use_null) const;
++ bm::null_support null_able = bm::use_null) const BMNOEXCEPT;
+
+ ///@}
+
+@@ -679,7 +684,7 @@
+
+ \return 0 - equal, < 0 - vect[i] < str, >0 otherwise
+ */
+- int compare(size_type idx, const value_type val) const;
++ int compare(size_type idx, const value_type val) const BMNOEXCEPT;
+
+ ///@}
+
+@@ -694,8 +699,9 @@
+ \param stat - memory allocation statistics after optimization
+ */
+ void optimize(bm::word_t* temp_block = 0,
+- typename bvector_type::optmode opt_mode = bvector_type::opt_compress,
+- typename sparse_vector<Val, BV>::statistics* stat = 0);
++ typename bvector_type::optmode opt_mode = bvector_type::opt_compress,
++ typename sparse_vector<Val, BV>::statistics* stat = 0);
++
+ /*!
+ \brief Optimize sizes of GAP blocks
+
+@@ -715,7 +721,8 @@
+
+ @sa statistics
+ */
+- void calc_stat(struct sparse_vector<Val, BV>::statistics* st) const;
++ void calc_stat(
++ struct sparse_vector<Val, BV>::statistics* st) const BMNOEXCEPT;
+ ///@}
+
+ // ------------------------------------------------------------
+@@ -789,7 +796,6 @@
+ \param offset - target index in the sparse vector to export from
+ \param zero_mem - set to false if target array is pre-initialized
+ with 0s to avoid performance penalty
+- \param pool_ptr - optional pointer to block allocation pool
+ \return number of exported elements
+
+ \sa decode
+@@ -799,8 +805,7 @@
+ size_type extract(value_type* arr,
+ size_type size,
+ size_type offset = 0,
+- bool zero_mem = true,
+- allocator_pool_type* pool_ptr = 0) const;
++ bool zero_mem = true) const BMNOEXCEPT2;
+
+ /** \brief extract small window without use of masking vector
+ \sa decode
+@@ -824,7 +829,7 @@
+ \internal
+ */
+ static
+- size_type translate_address(size_type i) { return i; }
++ size_type translate_address(size_type i) BMNOEXCEPT { return i; }
+
+ /**
+ \brief throw range error
+@@ -845,17 +850,17 @@
+ \brief find position of compressed element by its rank
+ */
+ static
+- bool find_rank(size_type rank, size_type& pos);
++ bool find_rank(size_type rank, size_type& pos) BMNOEXCEPT;
+
+ /**
+ \brief size of sparse vector (may be different for RSC)
+ */
+- size_type effective_size() const { return size(); }
++ size_type effective_size() const BMNOEXCEPT { return size(); }
+
+ /**
+ \brief Always 1 (non-matrix type)
+ */
+- size_type effective_vector_max() const { return 1; }
++ size_type effective_vector_max() const BMNOEXCEPT { return 1; }
+
+ ///@}
+
+@@ -862,7 +867,7 @@
+ /// Set allocator pool for local (non-threaded)
+ /// memory cyclic(lots of alloc-free ops) opertations
+ ///
+- void set_allocator_pool(allocator_pool_type* pool_ptr);
++ void set_allocator_pool(allocator_pool_type* pool_ptr) BMNOEXCEPT;
+
+ protected:
+ enum octet_plains
+@@ -886,20 +891,26 @@
+ void insert_value_no_null(size_type idx, value_type v);
+
+ void resize_internal(size_type sz) { resize(sz); }
+- size_type size_internal() const { return size(); }
++ size_type size_internal() const BMNOEXCEPT { return size(); }
+
+- bool is_remap() const { return false; }
+- size_t remap_size() const { return 0; }
+- const unsigned char* get_remap_buffer() const { return 0; }
+- unsigned char* init_remap_buffer() { return 0; }
+- void set_remap() { }
++ bool is_remap() const BMNOEXCEPT { return false; }
++ size_t remap_size() const BMNOEXCEPT { return 0; }
++ const unsigned char* get_remap_buffer() const BMNOEXCEPT { return 0; }
++ unsigned char* init_remap_buffer() BMNOEXCEPT { return 0; }
++ void set_remap() BMNOEXCEPT { }
+
+ bool resolve_range(size_type from, size_type to,
+- size_type* idx_from, size_type* idx_to) const
++ size_type* idx_from, size_type* idx_to) const BMNOEXCEPT
+ {
+ *idx_from = from; *idx_to = to; return true;
+ }
+
++ /// Increment element by 1 without chnaging NULL vector or size
++ void inc_no_null(size_type idx);
++
++ /// increment by v without chnaging NULL vector or size
++ void inc_no_null(size_type idx, value_type v);
++
+ protected:
+ template<class V, class SV> friend class rsc_sparse_vector;
+ template<class SVect> friend class sparse_vector_scanner;
+@@ -933,7 +944,7 @@
+ #ifndef BM_NO_CXX11
+
+ template<class Val, class BV>
+-sparse_vector<Val, BV>::sparse_vector(sparse_vector<Val, BV>&& sv) BMNOEXEPT
++sparse_vector<Val, BV>::sparse_vector(sparse_vector<Val, BV>&& sv) BMNOEXCEPT
+ {
+ parent_type::swap(sv);
+ }
+@@ -944,13 +955,13 @@
+ //---------------------------------------------------------------------
+
+ template<class Val, class BV>
+-sparse_vector<Val, BV>::~sparse_vector() BMNOEXEPT
++sparse_vector<Val, BV>::~sparse_vector() BMNOEXCEPT
+ {}
+
+ //---------------------------------------------------------------------
+
+ template<class Val, class BV>
+-void sparse_vector<Val, BV>::swap(sparse_vector<Val, BV>& sv) BMNOEXEPT
++void sparse_vector<Val, BV>::swap(sparse_vector<Val, BV>& sv) BMNOEXCEPT
+ {
+ parent_type::swap(sv);
+ }
+@@ -1080,19 +1091,7 @@
+ size_type dec_size,
+ bool zero_mem) const
+ {
+- if (dec_size < 32)
+- {
+- return extract_range(arr, dec_size, idx_from, zero_mem);
+- }
+- return extract_plains(arr, dec_size, idx_from, zero_mem);
+- // TODO: write proper extract() based on for_each_range() and a visitor
+- /*
+- if (dec_size < 1024)
+- {
+- return extract_plains(arr, dec_size, idx_from, zero_mem);
+- }
+ return extract(arr, dec_size, idx_from, zero_mem);
+- */
+ }
+
+ //---------------------------------------------------------------------
+@@ -1373,11 +1372,10 @@
+
+ template<class Val, class BV>
+ typename sparse_vector<Val, BV>::size_type
+-sparse_vector<Val, BV>::extract(value_type* arr,
++sparse_vector<Val, BV>::extract(value_type* BMRESTRICT arr,
+ size_type size,
+ size_type offset,
+- bool zero_mem,
+- allocator_pool_type* pool_ptr) const
++ bool zero_mem) const BMNOEXCEPT2
+ {
+ /// Decoder functor
+ /// @internal
+@@ -1384,78 +1382,55 @@
+ ///
+ struct sv_decode_visitor_func
+ {
+- sv_decode_visitor_func(value_type* varr,
++ sv_decode_visitor_func(value_type* BMRESTRICT varr,
+ value_type mask,
+- size_type off)
+- : arr_(varr), mask_(mask), off_(off)
++ size_type off) BMNOEXCEPT2
++ : arr_(varr), mask_(mask), sv_off_(off)
+ {}
+-
+- void add_bits(size_type arr_offset, const unsigned char* bits, unsigned bits_size)
++
++ void add_bits(size_type bv_offset,
++ const unsigned char* bits, unsigned bits_size) BMNOEXCEPT
+ {
+- size_type idx_base = arr_offset - off_;
+- const value_type m = mask_;
+- unsigned i = 0;
+- for (; i < bits_size; ++i)
+- arr_[idx_base + bits[i]] |= m;
++ // can be negative (-1) when bv base offset = 0 and sv = 1,2..
++ size_type base = bv_offset - sv_off_;
++ value_type m = mask_;
++ for (unsigned i = 0; i < bits_size; ++i)
++ arr_[bits[i] + base] |= m;
+ }
+-
+- void add_range(size_type arr_offset, unsigned sz)
++ void add_range(size_type bv_offset, size_type sz) BMNOEXCEPT
+ {
+- size_type idx_base = arr_offset - off_;
+- const value_type m = mask_;
+- for (unsigned i = 0; i < sz; ++i)
+- arr_[i + idx_base] |= m;
++ auto base = bv_offset - sv_off_;
++ value_type m = mask_;
++ for (size_type i = 0; i < sz; ++i)
++ arr_[i + base] |= m;
+ }
+- value_type* arr_;
+- value_type mask_;
+- size_type off_;
++
++ value_type* BMRESTRICT arr_; ///< target array for reverse transpose
++ value_type mask_; ///< bit-plane mask
++ size_type sv_off_; ///< SV read offset
+ };
+
+-
+- if (size == 0)
++ if (!size)
+ return 0;
+
+ if (zero_mem)
+ ::memset(arr, 0, sizeof(value_type)*size);
+
+- size_type start = offset;
+- size_type end = start + size;
++ size_type end = offset + size;
+ if (end > this->size_)
+- {
+ end = this->size_;
+- }
+-
+- bool masked_scan = !(offset == 0 && size == this->size());
+- if (masked_scan) // use temp vector to decompress the area
++
++ sv_decode_visitor_func func(arr, 0, offset);
++
++ for (size_type i = 0; i < parent_type::value_bits(); ++i)
+ {
+- bvector_type bv_mask;
+- bv_mask.set_allocator_pool(pool_ptr);
+-
+- for (size_type i = 0; i < parent_type::value_bits(); ++i)
+- {
+- const bvector_type* bv = this->bmatr_.get_row(i);
+- if (bv)
+- {
+- bv_mask.copy_range(*bv, offset, end - 1);
+- sv_decode_visitor_func func(arr, (value_type(1) << i), offset);
+- bm::for_each_bit(bv_mask, func);
+- }
+- } // for i
+- }
+- else
+- {
+- for (size_type i = 0; i < parent_type::value_bits(); ++i)
+- {
+- const bvector_type* bv = this->bmatr_.get_row(i);
+- if (bv)
+- {
+- sv_decode_visitor_func func(arr, (value_type(1) << i), 0);
+- bm::for_each_bit(*bv, func);
+- }
+- } // for i
+- }
+-
+- return end - start;
++ const bvector_type* bv = this->bmatr_.get_row(i);
++ if (!bv)
++ continue;
++ func.mask_ = (value_type(1) << i); // set target plane OR mask
++ bm::for_each_bit_range_no_check(*bv, offset, end-1, func);
++ } // for i
++ return end - offset;
+ }
+
+ //---------------------------------------------------------------------
+@@ -1473,7 +1448,8 @@
+
+ template<class Val, class BV>
+ typename sparse_vector<Val, BV>::value_type
+-sparse_vector<Val, BV>::get(typename sparse_vector<Val, BV>::size_type i) const
++sparse_vector<Val, BV>::get(
++ typename sparse_vector<Val, BV>::size_type i) const BMNOEXCEPT
+ {
+ BM_ASSERT(i < bm::id_max);
+ BM_ASSERT(i < size());
+@@ -1485,7 +1461,7 @@
+ bool b = this->bmatr_.test_4rows(j);
+ if (b)
+ {
+- value_type vm = this->bmatr_.get_half_octet(i, j);
++ value_type vm = (value_type)this->bmatr_.get_half_octet(i, j);
+ v |= vm << j;
+ }
+ } // for j
+@@ -1692,7 +1668,17 @@
+ {
+ if (idx >= this->size_)
+ this->size_ = idx+1;
++ inc_no_null(idx);
++ bvector_type* bv_null = this->get_null_bvect();
++ if (bv_null)
++ bv_null->set_bit_no_check(idx);
++}
+
++//---------------------------------------------------------------------
++
++template<class Val, class BV>
++void sparse_vector<Val, BV>::inc_no_null(size_type idx)
++{
+ for (unsigned i = 0; i < parent_type::sv_value_plains; ++i)
+ {
+ bvector_type* bv = this->get_plain(i);
+@@ -1700,16 +1686,22 @@
+ if (!carry_over)
+ break;
+ }
+- bvector_type* bv_null = this->get_null_bvect();
+- if (bv_null)
+- bv_null->set_bit_no_check(idx);
+ }
+
+ //---------------------------------------------------------------------
+
+ template<class Val, class BV>
+-void sparse_vector<Val, BV>::clear() BMNOEXEPT
++void sparse_vector<Val, BV>::inc_no_null(size_type idx, value_type v)
+ {
++ value_type v_prev = get(idx);
++ set_value_no_null(idx, v + v_prev);
++}
++
++//---------------------------------------------------------------------
++
++template<class Val, class BV>
++void sparse_vector<Val, BV>::clear() BMNOEXCEPT
++{
+ parent_type::clear();
+ }
+
+@@ -1716,7 +1708,7 @@
+ //---------------------------------------------------------------------
+
+ template<class Val, class BV>
+-bool sparse_vector<Val, BV>::find_rank(size_type rank, size_type& pos)
++bool sparse_vector<Val, BV>::find_rank(size_type rank, size_type& pos) BMNOEXCEPT
+ {
+ BM_ASSERT(rank);
+ pos = rank - 1;
+@@ -1740,7 +1732,7 @@
+
+ template<class Val, class BV>
+ void sparse_vector<Val, BV>::calc_stat(
+- struct sparse_vector<Val, BV>::statistics* st) const
++ struct sparse_vector<Val, BV>::statistics* st) const BMNOEXCEPT
+ {
+ BM_ASSERT(st);
+ typename bvector_type::statistics stbv;
+@@ -1906,7 +1898,8 @@
+ //---------------------------------------------------------------------
+
+ template<class Val, class BV>
+-int sparse_vector<Val, BV>::compare(size_type idx, const value_type val) const
++int sparse_vector<Val, BV>::compare(size_type idx,
++ const value_type val) const BMNOEXCEPT
+ {
+ // TODO: consider bit-by-bit comparison to minimize CPU hit miss in plans get()
+ value_type sv_value = get(idx);
+@@ -1917,7 +1910,7 @@
+
+ template<class Val, class BV>
+ bool sparse_vector<Val, BV>::equal(const sparse_vector<Val, BV>& sv,
+- bm::null_support null_able) const
++ bm::null_support null_able) const BMNOEXCEPT
+ {
+ return parent_type::equal(sv, null_able);
+ }
+@@ -1926,7 +1919,7 @@
+
+ template<class Val, class BV>
+ typename sparse_vector<Val, BV>::const_iterator
+-sparse_vector<Val, BV>::begin() const
++sparse_vector<Val, BV>::begin() const BMNOEXCEPT
+ {
+ typedef typename sparse_vector<Val, BV>::const_iterator it_type;
+ return it_type(this);
+@@ -1936,7 +1929,7 @@
+
+ template<class Val, class BV>
+ void sparse_vector<Val, BV>::set_allocator_pool(
+- typename sparse_vector<Val, BV>::allocator_pool_type* pool_ptr)
++ typename sparse_vector<Val, BV>::allocator_pool_type* pool_ptr) BMNOEXCEPT
+ {
+ this->bmatr_.set_allocator_pool(pool_ptr);
+ }
+@@ -1948,7 +1941,7 @@
+
+
+ template<class Val, class BV>
+-sparse_vector<Val, BV>::const_iterator::const_iterator()
++sparse_vector<Val, BV>::const_iterator::const_iterator() BMNOEXCEPT
+ : sv_(0), pos_(bm::id_max), buf_ptr_(0)
+ {}
+
+@@ -1956,7 +1949,7 @@
+
+ template<class Val, class BV>
+ sparse_vector<Val, BV>::const_iterator::const_iterator(
+- const typename sparse_vector<Val, BV>::const_iterator& it)
++ const typename sparse_vector<Val, BV>::const_iterator& it) BMNOEXCEPT
+ : sv_(it.sv_), pos_(it.pos_), buf_ptr_(0)
+ {}
+
+@@ -1964,7 +1957,8 @@
+
+ template<class Val, class BV>
+ sparse_vector<Val, BV>::const_iterator::const_iterator(
+- const typename sparse_vector<Val, BV>::const_iterator::sparse_vector_type* sv)
++ const typename sparse_vector<Val, BV>::const_iterator::sparse_vector_type* sv
++ ) BMNOEXCEPT
+ : sv_(sv), buf_ptr_(0)
+ {
+ BM_ASSERT(sv_);
+@@ -1976,7 +1970,7 @@
+ template<class Val, class BV>
+ sparse_vector<Val, BV>::const_iterator::const_iterator(
+ const typename sparse_vector<Val, BV>::const_iterator::sparse_vector_type* sv,
+- typename sparse_vector<Val, BV>::size_type pos)
++ typename sparse_vector<Val, BV>::size_type pos) BMNOEXCEPT
+ : sv_(sv), buf_ptr_(0)
+ {
+ BM_ASSERT(sv_);
+@@ -1986,7 +1980,7 @@
+ //---------------------------------------------------------------------
+
+ template<class Val, class BV>
+-void sparse_vector<Val, BV>::const_iterator::go_to(size_type pos)
++void sparse_vector<Val, BV>::const_iterator::go_to(size_type pos) BMNOEXCEPT
+ {
+ pos_ = (!sv_ || pos >= sv_->size()) ? bm::id_max : pos;
+ buf_ptr_ = 0;
+@@ -1995,22 +1989,23 @@
+ //---------------------------------------------------------------------
+
+ template<class Val, class BV>
+-void sparse_vector<Val, BV>::const_iterator::advance()
++bool sparse_vector<Val, BV>::const_iterator::advance() BMNOEXCEPT
+ {
+ if (pos_ == bm::id_max) // nothing to do, we are at the end
+- return;
++ return false;
+ ++pos_;
+ if (pos_ >= sv_->size())
++ {
+ this->invalidate();
+- else
++ return false;
++ }
++ if (buf_ptr_)
+ {
+- if (buf_ptr_)
+- {
+- ++buf_ptr_;
+- if (buf_ptr_ - ((value_type*)buffer_.data()) >= n_buf_size)
+- buf_ptr_ = 0;
+- }
++ ++buf_ptr_;
++ if (buf_ptr_ - ((value_type*)buffer_.data()) >= n_buf_size)
++ buf_ptr_ = 0;
+ }
++ return true;
+ }
+
+ //---------------------------------------------------------------------
+@@ -2026,7 +2021,7 @@
+ {
+ buffer_.reserve(n_buf_size * sizeof(value_type));
+ buf_ptr_ = (value_type*)(buffer_.data());
+- sv_->extract(buf_ptr_, n_buf_size, pos_, true, &pool_);
++ sv_->extract(buf_ptr_, n_buf_size, pos_, true);
+ }
+ v = *buf_ptr_;
+ return v;
+@@ -2035,7 +2030,7 @@
+ //---------------------------------------------------------------------
+
+ template<class Val, class BV>
+-void sparse_vector<Val, BV>::const_iterator::skip_zero_values()
++void sparse_vector<Val, BV>::const_iterator::skip_zero_values() BMNOEXCEPT
+ {
+ value_type v = value();
+ if (buf_ptr_)
+@@ -2063,7 +2058,7 @@
+ //---------------------------------------------------------------------
+
+ template<class Val, class BV>
+-bool sparse_vector<Val, BV>::const_iterator::is_null() const
++bool sparse_vector<Val, BV>::const_iterator::is_null() const BMNOEXCEPT
+ {
+ return sv_->is_null(pos_);
+ }
+Index: c++/include/util/bitset/bmsparsevec_algo.h
+===================================================================
+--- a/c++/include/util/bitset/bmsparsevec_algo.h (revision 90103)
++++ b/c++/include/util/bitset/bmsparsevec_algo.h (revision 90104)
+@@ -18,7 +18,7 @@
+ For more information please visit: http://bitmagic.io
+ */
+ /*! \file bmsparsevec_algo.h
+- \brief Algorithms for sparse_vector<>
++ \brief Algorithms for bm::sparse_vector
+ */
+
+ #ifndef BM__H__INCLUDED__
+@@ -31,6 +31,7 @@
+ #include "bmsparsevec.h"
+ #include "bmaggregator.h"
+ #include "bmbuffer.h"
++#include "bmalgo.h"
+ #include "bmdef.h"
+
+ #ifdef _MSC_VER
+@@ -231,7 +232,7 @@
+ } // null_proc
+ }
+
+- for (unsigned i = 0; mismatch & (i < plains1); ++i)
++ for (unsigned i = 0; mismatch && (i < plains1); ++i)
+ {
+ typename SV::bvector_type_const_ptr bv1 = sv1.get_plain(i);
+ typename SV::bvector_type_const_ptr bv2 = sv2.get_plain(i);
+@@ -503,7 +504,7 @@
+ /**
+ \brief reset sparse vector binding
+ */
+- void reset_binding();
++ void reset_binding() BMNOEXCEPT;
+
+ /**
+ \brief find all sparse vector elements EQ to search value
+@@ -709,7 +710,7 @@
+ int compare_str(const SV& sv, size_type idx, const value_type* str);
+
+ /// compare sv[idx] with input value
+- int compare(const SV& sv, size_type idx, const value_type val);
++ int compare(const SV& sv, size_type idx, const value_type val) BMNOEXCEPT;
+
+ protected:
+ sparse_vector_scanner(const sparse_vector_scanner&) = delete;
+@@ -1047,7 +1048,7 @@
+ {
+ sv_ptr_->gather(&gb_->buffer_[0], &gb_->gather_idx_[0], buf_cnt, BM_SORTED_UNIFORM);
+ bv_out.set(&gb_->buffer_[0], buf_cnt, BM_SORTED);
+- buf_cnt ^= buf_cnt;
++ buf_cnt = 0;
+ }
+ nb_old = nb;
+ gb_->gather_idx_[buf_cnt++] = idx;
+@@ -1061,7 +1062,7 @@
+ {
+ sv_ptr_->gather(&gb_->buffer_[0], &gb_->gather_idx_[0], buf_cnt, BM_SORTED_UNIFORM);
+ bv_out.set(&gb_->buffer_[0], buf_cnt, bm::BM_SORTED);
+- buf_cnt ^= buf_cnt;
++ buf_cnt = 0;
+ }
+ } // for en
+ if (buf_cnt)
+@@ -1157,7 +1158,7 @@
+ //----------------------------------------------------------------------------
+
+ template<typename SV>
+-void sparse_vector_scanner<SV>::reset_binding()
++void sparse_vector_scanner<SV>::reset_binding() BMNOEXCEPT
+ {
+ bound_sv_ = 0;
+ effective_str_max_ = 0;
+@@ -2020,7 +2021,7 @@
+ template<typename SV>
+ int sparse_vector_scanner<SV>::compare(const SV& sv,
+ size_type idx,
+- const value_type val)
++ const value_type val) BMNOEXCEPT
+ {
+ // TODO: implement sentinel elements cache (similar to compare_str())
+ return sv.compare(idx, val);
+Index: c++/include/util/bitset/bmdef.h
+===================================================================
+--- a/c++/include/util/bitset/bmdef.h (revision 90103)
++++ b/c++/include/util/bitset/bmdef.h (revision 90104)
+@@ -72,10 +72,15 @@
+ // cxx11 features
+ //
+ #if defined(BM_NO_CXX11) || (defined(_MSC_VER) && _MSC_VER < 1900)
+-# define BMNOEXEPT
++# define BMNOEXCEPT
++# define BMNOEXCEPT2
+ #else
+-# ifndef BMNOEXEPT
+-# define BMNOEXEPT noexcept
++# ifndef BMNOEXCEPT
++# define BMNOEXCEPT noexcept
++#if defined(__EMSCRIPTEN__)
++#else
++# define BMNOEXCEPT2
++#endif
+ # endif
+ #endif
+
+@@ -84,19 +89,17 @@
+ // detects use of EMSCRIPTEN engine and tweaks settings
+ // WebAssemply compiles into 32-bit ptr yet 64-bit wordsize use GCC extensions
+ //
++// BMNOEXCEPT2 is to declare "noexcept" for WebAsm only where needed
++// and silence GCC warnings where not
+ #if defined(__EMSCRIPTEN__)
+ # define BM64OPT
+ # define BM_USE_GCC_BUILD
+-//# define BM_FORBID_UNALIGNED_ACCESS
++# define BMNOEXCEPT2 noexcept
++#else
++# define BMNOEXCEPT2
+ #endif
+
+-// disable 'register' keyword, which is obsolete in C++11
+-//
+-#ifndef BMREGISTER
+-# define BMREGISTER
+-#endif
+
+-
+ // Enable MSVC 8.0 (2005) specific optimization options
+ //
+ #if(_MSC_VER >= 1400)
+Index: c++/include/util/bitset/bmbuffer.h
+===================================================================
+--- a/c++/include/util/bitset/bmbuffer.h (revision 90103)
++++ b/c++/include/util/bitset/bmbuffer.h (revision 90104)
+@@ -33,35 +33,35 @@
+ class byte_buffer_ptr
+ {
+ public:
+- byte_buffer_ptr()
++ byte_buffer_ptr() BMNOEXCEPT
+ : byte_buf_(0), size_(0)
+ {}
+
+ /// construct byte buffer pointer
+ ///
+- byte_buffer_ptr(unsigned char* in_buf, size_t in_size)
++ byte_buffer_ptr(unsigned char* in_buf, size_t in_size) BMNOEXCEPT
+ : byte_buf_(in_buf), size_(in_size)
+ {}
+
+ /// Set buffer pointer
+- void set_buf(unsigned char* in_buf, size_t in_size)
++ void set_buf(unsigned char* in_buf, size_t in_size) BMNOEXCEPT
+ {
+ byte_buf_ = in_buf; size_= in_size;
+ }
+
+ /// Get buffer size
+- size_t size() const { return size_; }
++ size_t size() const BMNOEXCEPT { return size_; }
+
+ /// Get read access to buffer memory
+- const unsigned char* buf() const { return byte_buf_; }
++ const unsigned char* buf() const BMNOEXCEPT { return byte_buf_; }
+
+ /// Get write access to buffer memory
+- unsigned char* data() { return byte_buf_; }
++ unsigned char* data() BMNOEXCEPT { return byte_buf_; }
+
+- bool operator==(const byte_buffer_ptr& lhs) const { return equal(lhs); }
++ bool operator==(const byte_buffer_ptr& lhs) const BMNOEXCEPT { return equal(lhs); }
+
+ /// return true if content and size is the same
+- bool equal(const byte_buffer_ptr& lhs) const
++ bool equal(const byte_buffer_ptr& lhs) const BMNOEXCEPT
+ {
+ if (this == &lhs)
+ return true;
+@@ -89,7 +89,7 @@
+ typedef size_t size_type;
+
+ public:
+- byte_buffer() : capacity_(0), alloc_factor_(0)
++ byte_buffer() BMNOEXCEPT : capacity_(0), alloc_factor_(0)
+ {}
+
+ byte_buffer(size_t in_capacity)
+@@ -98,7 +98,7 @@
+ allocate(in_capacity);
+ }
+
+- byte_buffer(const byte_buffer& lhs)
++ byte_buffer(const byte_buffer& lhs) BMNOEXCEPT
+ {
+ byte_buf_ = 0;
+ size_ = capacity_ = alloc_factor_ = 0;
+@@ -110,7 +110,7 @@
+
+ #ifndef BM_NO_CXX11
+ /// Move constructor
+- byte_buffer(byte_buffer&& in_buf) BMNOEXEPT
++ byte_buffer(byte_buffer&& in_buf) BMNOEXCEPT
+ {
+ byte_buf_ = in_buf.byte_buf_;
+ in_buf.byte_buf_ = 0;
+@@ -121,7 +121,7 @@
+ }
+
+ /// Move assignment operator
+- byte_buffer& operator=(byte_buffer&& lhs) BMNOEXEPT
++ byte_buffer& operator=(byte_buffer&& lhs) BMNOEXCEPT
+ {
+ move_from(lhs);
+ return *this;
+@@ -128,7 +128,7 @@
+ }
+ #endif
+
+- byte_buffer& operator=(const byte_buffer& lhs)
++ byte_buffer& operator=(const byte_buffer& lhs) BMNOEXCEPT
+ {
+ if (this == &lhs)
+ return *this;
+@@ -143,7 +143,7 @@
+ }
+
+ /// swap content with another buffer
+- void swap(byte_buffer& other) BMNOEXEPT
++ void swap(byte_buffer& other) BMNOEXCEPT
+ {
+ if (this == &other)
+ return;
+@@ -157,7 +157,7 @@
+ }
+
+ /// take/move content from another buffer
+- void move_from(byte_buffer& other) BMNOEXEPT
++ void move_from(byte_buffer& other) BMNOEXCEPT
+ {
+ if (this == &other)
+ return;
+@@ -190,7 +190,7 @@
+
+
+ /// Get buffer capacity
+- size_t capacity() const { return capacity_; }
++ size_t capacity() const BMNOEXCEPT { return capacity_; }
+
+ /// adjust current size (buffer content preserved)
+ void resize(size_t new_size, bool copy_content = true)
+@@ -213,6 +213,11 @@
+ {
+ if (new_capacity <= capacity_)
+ return;
++ if (!capacity_)
++ {
++ allocate(new_capacity);
++ return;
++ }
+
+ byte_buffer tmp_buffer(new_capacity);
+ tmp_buffer = *this;
+@@ -247,7 +252,7 @@
+ }
+
+ /// return memory consumtion
+- size_t mem_usage() const
++ size_t mem_usage() const BMNOEXCEPT
+ {
+ return sizeof(capacity_) + sizeof(alloc_factor_) +
+ capacity();
+@@ -258,7 +263,7 @@
+ void set_buf(unsigned char* buf, size_t size);
+
+ /// compute number of words for the desired capacity
+- static size_t compute_words(size_t capacity)
++ static size_t compute_words(size_t capacity) BMNOEXCEPT
+ {
+ size_t words = (capacity / sizeof(bm::word_t))+1;
+ return words;
+@@ -307,10 +312,8 @@
+ typedef Val value_type;
+ typedef typename buffer_type::size_type size_type;
+
+- heap_vector()
+- : buffer_()
+- {
+- }
++ heap_vector() BMNOEXCEPT : buffer_()
++ {}
+
+ heap_vector(const heap_vector<Val, BVAlloc, trivial_type>& hv)
+ : buffer_()
+@@ -359,14 +362,14 @@
+ }
+ }
+
+- value_type* data() { return (value_type*) buffer_.data(); }
++ value_type* data() BMNOEXCEPT { return (value_type*) buffer_.data(); }
+
+- void swap(heap_vector<Val, BVAlloc, trivial_type>& other) BMNOEXEPT
++ void swap(heap_vector<Val, BVAlloc, trivial_type>& other) BMNOEXCEPT
+ {
+ buffer_.swap(other.buffer_);
+ }
+
+- const value_type& operator[](size_type pos) const
++ const value_type& operator[](size_type pos) const BMNOEXCEPT
+ {
+ BM_ASSERT(pos < size());
+ size_type v_size = value_size();
+@@ -374,7 +377,7 @@
+ return *reinterpret_cast<const value_type*>(p);
+ }
+
+- value_type& operator[](size_type pos)
++ value_type& operator[](size_type pos) BMNOEXCEPT
+ {
+ BM_ASSERT(pos < size());
+ size_type v_size = value_size();
+@@ -393,22 +396,22 @@
+ return *reinterpret_cast<value_type*>(p);
+ }
+
+- const value_type* begin() const
++ const value_type* begin() const BMNOEXCEPT
+ {
+ return (const value_type*) buffer_.buf();
+ }
+
+- size_type size() const
++ size_type size() const BMNOEXCEPT
+ {
+ return buffer_.size() / value_size();
+ }
+
+- size_type capacity() const
++ size_type capacity() const BMNOEXCEPT
+ {
+ return buffer_.capacity() / value_size();
+ }
+
+- bool empty() const
++ bool empty() const BMNOEXCEPT
+ {
+ return (buffer_.size() == 0);
+ }
+@@ -492,7 +495,7 @@
+ buffer_.resize(new_size * v_size);
+ }
+
+- static size_type value_size()
++ static size_type value_size() BMNOEXCEPT
+ {
+ size_type size_of = sizeof(value_type);
+ return size_of;
+@@ -537,13 +540,13 @@
+ row_size_in_bytes = sizeof(value_type) * COLS
+ };
+
+- static size_t rows() { return ROWS; }
+- static size_t cols() { return COLS; }
++ static size_t rows() BMNOEXCEPT { return ROWS; }
++ static size_t cols() BMNOEXCEPT { return COLS; }
+
+ /**
+ By default object is constructed NOT allocated.
+ */
+- heap_matrix()
++ heap_matrix() BMNOEXCEPT
+ : buffer_()
+ {}
+
+@@ -565,12 +568,12 @@
+ buffer_.resize(size_in_bytes);
+ }
+
+- bool is_init() const
++ bool is_init() const BMNOEXCEPT
+ {
+ return buffer_.size();
+ }
+
+- value_type get(size_type row_idx, size_type col_idx) const
++ value_type get(size_type row_idx, size_type col_idx) const BMNOEXCEPT
+ {
+ BM_ASSERT(row_idx < ROWS);
+ BM_ASSERT(col_idx < COLS);
+@@ -579,7 +582,7 @@
+ return ((const value_type*)buf)[col_idx];
+ }
+
+- const value_type* row(size_type row_idx) const
++ const value_type* row(size_type row_idx) const BMNOEXCEPT
+ {
+ BM_ASSERT(row_idx < ROWS);
+ BM_ASSERT(buffer_.size());
+@@ -587,7 +590,7 @@
+ return (const value_type*) buf;
+ }
+
+- value_type* row(size_type row_idx)
++ value_type* row(size_type row_idx) BMNOEXCEPT
+ {
+ BM_ASSERT(row_idx < ROWS);
+ BM_ASSERT(buffer_.size());
+@@ -597,7 +600,7 @@
+ }
+
+ /** memset all buffer to all zeroes */
+- void set_zero()
++ void set_zero() BMNOEXCEPT
+ {
+ ::memset(buffer_.data(), 0, size_in_bytes);
+ }
+@@ -604,7 +607,7 @@
+
+ /*! swap content
+ */
+- void swap(heap_matrix& other) BMNOEXEPT
++ void swap(heap_matrix& other) BMNOEXCEPT
+ {
+ buffer_.swap(other.buffer_);
+ }
+@@ -611,7 +614,7 @@
+
+ /*! move content from another matrix
+ */
+- void move_from(heap_matrix& other) BMNOEXEPT
++ void move_from(heap_matrix& other) BMNOEXCEPT
+ {
+ buffer_.move_from(other.buffer_);
+ }
+@@ -624,7 +627,7 @@
+ /*! remapping: vect[idx] = matrix[idx, vect[idx] ]
+ */
+ template<typename VECT_TYPE>
+- void remap(VECT_TYPE* vect, size_type size) const
++ void remap(VECT_TYPE* vect, size_type size) const BMNOEXCEPT
+ {
+ BM_ASSERT(size <= ROWS);
+ const unsigned char* buf = buffer_.buf();
+@@ -641,7 +644,7 @@
+ /*! zero-terminated remap: vect[idx] = matrix[idx, vect[idx] ]
+ */
+ template<typename VECT_TYPE>
+- void remapz(VECT_TYPE* vect) const
++ void remapz(VECT_TYPE* vect) const BMNOEXCEPT
+ {
+ const unsigned char* buf = buffer_.buf();
+ for (size_type i = 0; i < ROWS; ++i)
+@@ -704,12 +707,12 @@
+ buffer_.resize(size_in_bytes());
+ }
+
+- bool is_init() const
++ bool is_init() const BMNOEXCEPT
+ {
+ return buffer_.size();
+ }
+
+- const value_type* row(size_type row_idx) const
++ const value_type* row(size_type row_idx) const BMNOEXCEPT
+ {
+ BM_ASSERT(row_idx < rows_);
+ BM_ASSERT(buffer_.size());
+@@ -717,7 +720,7 @@
+ return (const value_type*) buf;
+ }
+
+- value_type* row(size_type row_idx)
++ value_type* row(size_type row_idx) BMNOEXCEPT
+ {
+ BM_ASSERT(row_idx < rows_);
+ BM_ASSERT(buffer_.size());
+@@ -726,8 +729,24 @@
+ return (value_type*)buf;
+ }
+
++ value_type get(size_type row_idx, size_type col_idx) BMNOEXCEPT
++ {
++ BM_ASSERT(row_idx < rows_);
++ BM_ASSERT(col_idx < cols_);
++ const value_type* r = row(row_idx);
++ return r[col_idx];
++ }
++
++ void set(size_type row_idx, size_type col_idx, value_type v) BMNOEXCEPT
++ {
++ BM_ASSERT(row_idx < rows_);
++ BM_ASSERT(col_idx < cols_);
++ value_type* r = row(row_idx);
++ r[col_idx] = v;
++ }
++
+ /** memset all buffer to all zeroes */
+- void set_zero()
++ void set_zero() BMNOEXCEPT
+ {
+ ::memset(buffer_.data(), 0, size_in_bytes());
+ }
+@@ -734,7 +753,7 @@
+
+ /*! swap content
+ */
+- void swap(dynamic_heap_matrix& other) BMNOEXEPT
++ void swap(dynamic_heap_matrix& other) BMNOEXCEPT
+ {
+ bm::xor_swap(rows_, other.rows_);
+ bm::xor_swap(cols_, other.cols_);
+@@ -743,7 +762,7 @@
+
+ /*! move content from another matrix
+ */
+- void move_from(dynamic_heap_matrix& other) BMNOEXEPT
++ void move_from(dynamic_heap_matrix& other) BMNOEXCEPT
+ {
+ rows_ = other.rows_;
+ cols_ = other.cols_;
+@@ -751,16 +770,46 @@
+ }
+
+ /** Get low-level buffer access */
+- buffer_type& get_buffer() { return buffer_; }
++ buffer_type& get_buffer() BMNOEXCEPT { return buffer_; }
+ /** Get low-level buffer access */
+- const buffer_type& get_buffer() const { return buffer_; }
++ const buffer_type& get_buffer() const BMNOEXCEPT { return buffer_; }
+
++ /**
++ copy values of the left triangle elements to the right triangle
++ (operation specific to matrices with symmetric distances)
++ */
++ void replicate_triange() BMNOEXCEPT
++ {
++ BM_ASSERT(rows_ == cols_);
++ for (size_type i = 0; i < rows_; ++i)
++ {
++ for (size_type j = i+1; j < cols_; ++j)
++ {
++ set(i, j, get(j, i));
++ }
++ }
++ }
++ /**
++ Sum of row elements
++ */
++ template<typename ACC>
++ void sum(ACC& acc, size_type row_idx) const BMNOEXCEPT
++ {
++ BM_ASSERT(row_idx < rows_);
++ ACC s = 0;
++ const value_type* r = row(row_idx);
++ for (size_type j = 0; j < cols_; ++j)
++ s += r[j];
++ acc = s;
++ }
++
+ protected:
+- size_type size_in_bytes() const
++
++ size_type size_in_bytes() const BMNOEXCEPT
+ {
+ return sizeof(value_type) * cols_ * rows_;
+ }
+- size_type row_size_in_bytes() const
++ size_type row_size_in_bytes() const BMNOEXCEPT
+ {
+ return sizeof(value_type) * cols_;
+ }
+Index: c++/include/util/bitset/bmavx2.h
+===================================================================
+--- a/c++/include/util/bitset/bmavx2.h (revision 90103)
++++ b/c++/include/util/bitset/bmavx2.h (revision 90104)
+@@ -223,6 +223,66 @@
+ }
+
+ /*!
++ @brief Calculate population count based on digest
++
++ @return popcnt
++ @ingroup AVX2
++*/
++inline
++bm::id_t avx2_bit_block_count(const bm::word_t* const block,
++ bm::id64_t digest)
++{
++ bm::id_t count = 0;
++ bm::id64_t* cnt64;
++ BM_AVX2_POPCNT_PROLOG;
++ __m256i cnt = _mm256_setzero_si256();
++ while (digest)
++ {
++ bm::id64_t t = bm::bmi_blsi_u64(digest); // d & -d;
++
++ unsigned wave = _mm_popcnt_u64(t - 1);
++ unsigned off = wave * bm::set_block_digest_wave_size;
++
++ const __m256i* BMRESTRICT wave_src = (__m256i*)&block[off];
++
++ __m256i m1A, m1B, m1C, m1D;
++ m1A = _mm256_load_si256(wave_src);
++ m1B = _mm256_load_si256(wave_src+1);
++ if (!_mm256_testz_si256(m1A, m1A))
++ {
++ BM_AVX2_BIT_COUNT(bc, m1A)
++ cnt = _mm256_add_epi64(cnt, bc);
++ }
++ if (!_mm256_testz_si256(m1B, m1B))
++ {
++ BM_AVX2_BIT_COUNT(bc, m1B)
++ cnt = _mm256_add_epi64(cnt, bc);
++ }
++
++ m1C = _mm256_load_si256(wave_src+2);
++ m1D = _mm256_load_si256(wave_src+3);
++ if (!_mm256_testz_si256(m1C, m1C))
++ {
++ BM_AVX2_BIT_COUNT(bc, m1C)
++ cnt = _mm256_add_epi64(cnt, bc);
++ }
++ if (!_mm256_testz_si256(m1D, m1D))
++ {
++ BM_AVX2_BIT_COUNT(bc, m1D)
++ cnt = _mm256_add_epi64(cnt, bc);
++ }
++
++ digest = bm::bmi_bslr_u64(digest); // d &= d - 1;
++ } // while
++ cnt64 = (bm::id64_t*)&cnt;
++ count = (unsigned)(cnt64[0] + cnt64[1] + cnt64[2] + cnt64[3]);
++ return count;
++
++}
++
++
++
++/*!
+ @brief AND bit count for two aligned bit-blocks
+ @ingroup AVX2
+ */
+@@ -1368,6 +1428,20 @@
+ }
+
+ /*!
++ @brief check if wave of pointers is all 0xFFF
++ @ingroup AVX2
++*/
++BMFORCEINLINE
++bool avx2_test_all_one_wave(const void* ptr)
++{
++ __m256i maskF = _mm256_set1_epi32(~0u); // braodcast 0xFF
++ __m256i wcmpA = _mm256_cmpeq_epi8(_mm256_loadu_si256((__m256i*)ptr), maskF); // (w0 == maskF)
++ unsigned maskA = unsigned(_mm256_movemask_epi8(wcmpA));
++ return (maskA == ~0u);
++}
++
++
++/*!
+ @brief check if wave of pointers is all NULL
+ @ingroup AVX2
+ */
+@@ -2474,16 +2548,24 @@
+ }
+
+ /**
+- hybrid binary search, starts as binary, then switches to scan
+-
++ Hybrid binary search, starts as binary, then switches to scan
++
+ NOTE: AVX code uses _mm256_subs_epu16 - saturated substraction
+ which gives 0 if A-B=0 if A < B (not negative a value).
+-
++
++ \param buf - GAP buffer pointer.
++ \param pos - index of the element.
++ \param is_set - output. GAP value (0 or 1).
++ \return GAP index.
++
+ @ingroup AVX2
+ */
+ inline
+-unsigned avx2_gap_test(const unsigned short* buf, unsigned pos)
++unsigned avx2_gap_bfind(const unsigned short* BMRESTRICT buf,
++ unsigned pos, unsigned* BMRESTRICT is_set)
+ {
++ BM_ASSERT(is_set);
++
+ const unsigned linear_cutoff = 48;
+ const unsigned unroll_factor = 16;
+
+@@ -2500,8 +2582,9 @@
+ {
+ if (buf[start] >= pos)
+ {
+- res = ((*buf) & 1) ^ ((--start) & 1);
+- return res;
++ res = ((*buf) & 1) ^ ((start-1) & 1);
++ *is_set = res;
++ return start;
+ }
+ } // for
+ BM_ASSERT(0);
+@@ -2516,7 +2599,7 @@
+ // but stay within allocated block memory
+ //
+ dsize = arr_end - start;
+-
++
+ __m256i mZ = _mm256_setzero_si256();
+ __m256i mPos = _mm256_set1_epi16((unsigned short)pos);
+ __m256i vect16, mSub, mge_mask;
+@@ -2532,8 +2615,9 @@
+ {
+ int lz = _tzcnt_u32(mask) / 2;
+ start += lz;
+- res = ((*buf) & 1) ^ ((--start) & 1);
+- return res;
++ res = ((*buf) & 1) ^ ((start-1) & 1);
++ *is_set = res;
++ return start;
+ }
+ } // for k
+ unsigned tail = unroll_factor - (end - start);
+@@ -2544,22 +2628,19 @@
+ mSub = _mm256_subs_epu16(mPos, vect16);
+ mge_mask = _mm256_cmpeq_epi16(mSub, mZ);
+ int mask = _mm256_movemask_epi8(mge_mask);
+- BM_ASSERT(mask);
+- // TODO: if should be not needed, cleanup
+- if (mask)
+- {
+- int lz = _tzcnt_u32(mask) / 2;
+- start += lz;
+- res = ((*buf) & 1) ^ ((--start) & 1);
+- return res;
+- }
+- start += unroll_factor; // remove with if when sure
++ BM_ASSERT(mask); // the rersult MUST be here at this point
++
++ int lz = _tzcnt_u32(mask) / 2;
++ start += lz;
++ res = ((*buf) & 1) ^ ((start-1) & 1);
++ *is_set = res;
++ return start;
+ }
+ for (; start < end; ++start)
+ {
+ if (buf[start] >= pos)
+ break;
+- }
++ } // for
+ break;
+ }
+ unsigned curr = (start + end) >> 1;
+@@ -2568,11 +2649,25 @@
+ else
+ end = curr;
+ } // while
+- res = ((*buf) & 1) ^ ((--start) & 1);
+- return res;
++ res = ((*buf) & 1) ^ ((start-1) & 1);
++ *is_set = res;
++ return start;
+ }
+
++
+ /**
++ Hybrid binary search, starts as binary, then switches to scan
++ @ingroup AVX2
++*/
++inline
++unsigned avx2_gap_test(const unsigned short* BMRESTRICT buf, unsigned pos)
++{
++ unsigned is_set;
++ bm::avx2_gap_bfind(buf, pos, &is_set);
++ return is_set;
++}
++
++/**
+ lower bound (great or equal) linear scan in ascending order sorted array
+ @ingroup AVX2
+ \internal
+@@ -3024,6 +3119,13 @@
+ #define VECT_BIT_BLOCK_XOR(t, src, src_xor, d) \
+ avx2_bit_block_xor(t, src, src_xor, d)
+
++#define VECT_GAP_BFIND(buf, pos, is_set) \
++ avx2_gap_bfind(buf, pos, is_set)
++
++#define VECT_BIT_COUNT_DIGEST(blk, d) \
++ avx2_bit_block_count(blk, d)
++
++
+ } // namespace
+
+
+Index: c++/include/util/bitset/bmrandom.h
+===================================================================
+--- a/c++/include/util/bitset/bmrandom.h (revision 90103)
++++ b/c++/include/util/bitset/bmrandom.h (revision 90104)
+@@ -97,7 +97,7 @@
+ unsigned process_word(bm::word_t* blk_out,
+ const bm::word_t* blk_src,
+ unsigned nword,
+- unsigned take_count);
++ unsigned take_count) BMNOEXCEPT;
+
+ static
+ void get_random_array(bm::word_t* blk_out,
+@@ -106,7 +106,7 @@
+ unsigned count);
+ static
+ unsigned compute_take_count(unsigned bc,
+- size_type in_count, size_type sample_count);
++ size_type in_count, size_type sample_count) BMNOEXCEPT;
+
+
+ private:
+@@ -357,9 +357,10 @@
+ }
+
+ template<class BV>
+-unsigned random_subset<BV>::compute_take_count(unsigned bc,
+- size_type in_count,
+- size_type sample_count)
++unsigned random_subset<BV>::compute_take_count(
++ unsigned bc,
++ size_type in_count,
++ size_type sample_count) BMNOEXCEPT
+ {
+ float block_percent = float(bc) / float(in_count);
+ float bits_to_take = float(sample_count) * block_percent;
+@@ -404,7 +405,7 @@
+ }
+ // now transform vacant bits to array, then pick random elements
+ //
+- unsigned arr_len = bit_convert_to_arr(bit_list_,
++ unsigned arr_len = bm::bit_convert_to_arr(bit_list_,
+ sub_block_,
+ bm::gap_max_bits,
+ bm::gap_max_bits,
+@@ -418,7 +419,7 @@
+ unsigned random_subset<BV>::process_word(bm::word_t* blk_out,
+ const bm::word_t* blk_src,
+ unsigned nword,
+- unsigned take_count)
++ unsigned take_count) BMNOEXCEPT
+ {
+ unsigned new_bits, mask;
+ do
+Index: c++/include/util/bitset/bmtimer.h
+===================================================================
+--- a/c++/include/util/bitset/bmtimer.h (revision 90103)
++++ b/c++/include/util/bitset/bmtimer.h (revision 90104)
+@@ -46,7 +46,7 @@
+ std::chrono::duration<double, std::milli> duration;
+ unsigned repeats;
+
+- statistics() : repeats(1) {}
++ statistics() : duration(0), repeats(1) {}
+
+ statistics(std::chrono::duration<double, std::milli> d, unsigned r)
+ : duration(d), repeats(r)
+@@ -147,7 +147,13 @@
+ if (ms > 1000)
+ {
+ double sec = ms / 1000;
+- std::cout << it->first << "; " << std::setprecision(4) << sec << " sec" << std::endl;
++ if (sec > 60)
++ {
++ double min = sec / 60;
++ std::cout << it->first << "; " << std::setprecision(4) << min << " min" << std::endl;
++ }
++ else
++ std::cout << it->first << "; " << std::setprecision(4) << sec << " sec" << std::endl;
+ }
+ else
+ std::cout << it->first << "; " << it->second.duration.count() << " ms" << std::endl;
+Index: c++/include/util/bitset/bmalgo.h
+===================================================================
+--- a/c++/include/util/bitset/bmalgo.h (revision 90103)
++++ b/c++/include/util/bitset/bmalgo.h (revision 90104)
+@@ -46,7 +46,7 @@
+ \ingroup setalgo
+ */
+ template<class BV>
+-typename BV::size_type count_and(const BV& bv1, const BV& bv2)
++typename BV::size_type count_and(const BV& bv1, const BV& bv2) BMNOEXCEPT
+ {
+ return bm::distance_and_operation(bv1, bv2);
+ }
+@@ -59,7 +59,7 @@
+ \ingroup setalgo
+ */
+ template<class BV>
+-typename BV::size_type any_and(const BV& bv1, const BV& bv2)
++typename BV::size_type any_and(const BV& bv1, const BV& bv2) BMNOEXCEPT
+ {
+ distance_metric_descriptor dmd(bm::COUNT_AND);
+
+@@ -78,7 +78,7 @@
+ */
+ template<class BV>
+ bm::distance_metric_descriptor::size_type
+-count_xor(const BV& bv1, const BV& bv2)
++count_xor(const BV& bv1, const BV& bv2) BMNOEXCEPT
+ {
+ distance_metric_descriptor dmd(bm::COUNT_XOR);
+
+@@ -94,7 +94,7 @@
+ \ingroup setalgo
+ */
+ template<class BV>
+-typename BV::size_type any_xor(const BV& bv1, const BV& bv2)
++typename BV::size_type any_xor(const BV& bv1, const BV& bv2) BMNOEXCEPT
+ {
+ distance_metric_descriptor dmd(bm::COUNT_XOR);
+
+@@ -112,7 +112,7 @@
+ \ingroup setalgo
+ */
+ template<class BV>
+-typename BV::size_type count_sub(const BV& bv1, const BV& bv2)
++typename BV::size_type count_sub(const BV& bv1, const BV& bv2) BMNOEXCEPT
+ {
+ distance_metric_descriptor dmd(bm::COUNT_SUB_AB);
+
+@@ -129,7 +129,7 @@
+ \ingroup setalgo
+ */
+ template<class BV>
+-typename BV::size_type any_sub(const BV& bv1, const BV& bv2)
++typename BV::size_type any_sub(const BV& bv1, const BV& bv2) BMNOEXCEPT
+ {
+ distance_metric_descriptor dmd(bm::COUNT_SUB_AB);
+
+@@ -146,7 +146,7 @@
+ \ingroup setalgo
+ */
+ template<class BV>
+-typename BV::size_type count_or(const BV& bv1, const BV& bv2)
++typename BV::size_type count_or(const BV& bv1, const BV& bv2) BMNOEXCEPT
+ {
+ distance_metric_descriptor dmd(bm::COUNT_OR);
+
+@@ -162,7 +162,7 @@
+ \ingroup setalgo
+ */
+ template<class BV>
+-typename BV::size_type any_or(const BV& bv1, const BV& bv2)
++typename BV::size_type any_or(const BV& bv1, const BV& bv2) BMNOEXCEPT
+ {
+ distance_metric_descriptor dmd(bm::COUNT_OR);
+
+@@ -173,18 +173,18 @@
+
+
+ #define BM_SCANNER_OP(x) \
+- if (0 != (block = blk_blk[j+x])) \
++if (0 != (block = blk_blk[j+x])) \
++{ \
++ if (BM_IS_GAP(block)) \
+ { \
+- if (BM_IS_GAP(block)) \
+- { \
+- bm::for_each_gap_blk(BMGAP_PTR(block), (r+j+x)*bm::bits_in_block,\
+- bit_functor); \
+- } \
+- else \
+- { \
+- bm::for_each_bit_blk(block, (r+j+x)*bm::bits_in_block,bit_functor); \
+- } \
+- }
++ bm::for_each_gap_blk(BMGAP_PTR(block), (r+j+x)*bm::bits_in_block,\
++ bit_functor); \
++ } \
++ else \
++ { \
++ bm::for_each_bit_blk(block, (r+j+x)*bm::bits_in_block,bit_functor); \
++ } \
++}
+
+
+ /**
+@@ -191,9 +191,10 @@
+ @brief bit-vector visitor scanner to traverse each 1 bit using C++ visitor
+
+ @param bv - bit vector to scan
+- @param bit_functor (should support add_bits() and add_range() methods
++ @param bit_functor - visitor: should support add_bits(), add_range()
+
+ \ingroup setalgo
++ @sa for_each_bit_range visit_each_bit
+ */
+ template<class BV, class Func>
+ void for_each_bit(const BV& bv,
+@@ -248,10 +249,100 @@
+ } // for i
+ }
+
++/**
++ @brief bit-vector range visitor to traverse each 1 bit
++
++ @param bv - bit vector to scan
++ @param right - start of closed interval [from..to]
++ @param left - end of close interval [from..to]
++ @param bit_functor - visitor: should support add_bits(), add_range()
++
++ \ingroup setalgo
++ @sa for_each_bit
++*/
++template<class BV, class Func>
++void for_each_bit_range(const BV& bv,
++ typename BV::size_type left,
++ typename BV::size_type right,
++ Func& bit_functor)
++{
++ if (left > right)
++ bm::xor_swap(left, right);
++ if (right == bm::id_max)
++ --right;
++ BM_ASSERT(left < bm::id_max && right < bm::id_max);
++
++ bm::for_each_bit_range_no_check(bv, left, right, bit_functor);
++}
++
++
+ #undef BM_SCANNER_OP
+
++
++/// private adaptor for C-style callbacks
++///
++/// @internal
++///
++template <class VCBT, class size_type>
++struct bit_vitor_callback_adaptor
++{
++ typedef VCBT bit_visitor_callback_type;
++
++ bit_vitor_callback_adaptor(void* h, bit_visitor_callback_type cb_func)
++ : handle_(h), func_(cb_func)
++ {}
++
++ void add_bits(size_type offset, const unsigned char* bits, unsigned size)
++ {
++ for (unsigned i = 0; i < size; ++i)
++ func_(handle_, offset + bits[i]);
++ }
++ void add_range(size_type offset, size_type size)
++ {
++ for (size_type i = 0; i < size; ++i)
++ func_(handle_, offset + i);
++ }
++
++ void* handle_;
++ bit_visitor_callback_type func_;
++};
++
++
++/// Functor for bit-copy (for testing)
++///
++/// @internal
++///
++template <class BV>
++struct bit_vistor_copy_functor
++{
++ typedef typename BV::size_type size_type;
++
++ bit_vistor_copy_functor(BV& bv)
++ : bv_(bv)
++ {
++ bv_.init();
++ }
++
++ void add_bits(size_type offset, const unsigned char* bits, unsigned size)
++ {
++ BM_ASSERT(size);
++ for (unsigned i = 0; i < size; ++i)
++ bv_.set_bit_no_check(offset + bits[i]);
++ }
++ void add_range(size_type offset, size_type size)
++ {
++ BM_ASSERT(size);
++ bv_.set_range(offset, offset + size - 1);
++ }
++
++ BV& bv_;
++ bit_visitor_callback_type func_;
++};
++
++
++
+ /**
+- @brief bit-vector visitor scanner to traverse each 1 bit using C callback
++ @brief bvector visitor scanner to traverse each 1 bit using C callback
+
+ @param bv - bit vector to scan
+ @param handle_ptr - handle to private memory used by callback
+@@ -267,33 +358,101 @@
+ bit_visitor_callback_type callback_ptr)
+ {
+ typedef typename BV::size_type size_type;
+- // private adaptor for C-style callbacks
+- struct callback_adaptor
++ bm::bit_vitor_callback_adaptor<bit_visitor_callback_type, size_type>
++ func(handle_ptr, callback_ptr);
++ bm::for_each_bit(bv, func);
++}
++
++/**
++ @brief bvector visitor scanner to traverse each bits in range (C callback)
++
++ @param bv - bit vector to scan
++ @param left - from [left..right]
++ @param right - to [left..right]
++ @param handle_ptr - handle to private memory used by callback
++ @param callback_ptr - callback function
++
++ \ingroup setalgo
++
++ @sa bit_visitor_callback_type for_each_bit
++*/
++template<class BV>
++void visit_each_bit_range(const BV& bv,
++ typename BV::size_type left,
++ typename BV::size_type right,
++ void* handle_ptr,
++ bit_visitor_callback_type callback_ptr)
++{
++ typedef typename BV::size_type size_type;
++ bm::bit_vitor_callback_adaptor<bit_visitor_callback_type, size_type>
++ func(handle_ptr, callback_ptr);
++ bm::for_each_bit_range(bv, left, right, func);
++}
++
++/**
++ @brief Algorithm to identify bit-vector ranges (splits) for the rank
++
++ Rank range split algorithm walks the bit-vector to create list of
++ non-overlapping ranges [s1..e1],[s2..e2]...[sN...eN] with requested
++ (rank) number of 1 bits. All ranges should be the same popcount weight,
++ except the last one, which may have less.
++ Scan is progressing from left to right so result ranges will be
++ naturally sorted.
++
++ @param bv - bit vector to perform the range split scan
++ @param rank - requested number of bits in each range
++ if 0 it will create single range [first..last]
++ to cover the whole bv
++ @param target_v - [out] STL(or STL-like) vector of pairs to keep pairs results
++
++ \ingroup setalgo
++ */
++template<typename BV, typename PairVect>
++void rank_range_split(const BV& bv,
++ typename BV::size_type rank,
++ PairVect& target_v)
++{
++ target_v.resize(0);
++ typename BV::size_type first, last, pos;
++ bool found = bv.find_range(first, last);
++ if (!found) // empty bit-vector
++ return;
++
++ if (!rank) // if rank is not defined, include the whole vector [first..last]
+ {
+- callback_adaptor(void* h, bit_visitor_callback_type cb_func)
+- : handle_(h), func_(cb_func)
+- {}
+-
+- void add_bits(size_type offset, const unsigned char* bits, unsigned size)
++ typename PairVect::value_type pv;
++ pv.first = first; pv.second = last;
++ target_v.push_back(pv);
++ return;
++ }
++
++ while (1)
++ {
++ typename PairVect::value_type pv;
++ found = bv.find_rank(rank, first, pos);
++ if (found)
+ {
+- for (unsigned i = 0; i < size; ++i)
+- func_(handle_, offset + bits[i]);
++ pv.first = first; pv.second = pos;
++ target_v.push_back(pv);
++ if (pos >= last)
++ break;
++ first = pos + 1;
++ continue;
+ }
+- void add_range(size_type offset, unsigned size)
++ // insufficient rank (last range)
++ found = bv.any_range(first, last);
++ if (found)
+ {
+- for (unsigned i = 0; i < size; ++i)
+- func_(handle_, offset + i);
++ pv.first = first; pv.second = last;
++ target_v.push_back(pv);
+ }
+-
+- void* handle_;
+- bit_visitor_callback_type func_;
+- };
+-
+- callback_adaptor func(handle_ptr, callback_ptr);
+- bm::for_each_bit(bv, func);
++ break;
++ } // while
++
+ }
+
+
++
+ /**
+ Algorithms for rank compression of bit-vector
+
+@@ -562,6 +721,7 @@
+
+
+
++
+ } // bm
+
+ #include "bmundef.h"
+Index: c++/include/util/bitset/bmrs.h
+===================================================================
+--- a/c++/include/util/bitset/bmrs.h (revision 90103)
++++ b/c++/include/util/bitset/bmrs.h (revision 90104)
+@@ -59,7 +59,7 @@
+ rs_index(const rs_index& rsi);
+
+ /// init arrays to zeros
+- void init() BMNOEXEPT;
++ void init() BMNOEXCEPT;
+
+ /// copy rs index
+ void copy_from(const rs_index& rsi);
+@@ -165,7 +165,7 @@
+
+
+ template<typename BVAlloc>
+-void rs_index<BVAlloc>::init() BMNOEXEPT
++void rs_index<BVAlloc>::init() BMNOEXCEPT
+ {
+ sblock_count_.resize(0);
+ sblock_row_idx_.resize(0);
+Index: c++/include/util/bitset/bmconst.h
+===================================================================
+--- a/c++/include/util/bitset/bmconst.h (revision 90103)
++++ b/c++/include/util/bitset/bmconst.h (revision 90104)
+@@ -96,14 +96,14 @@
+ const unsigned set_array_mask = 0xFFu;
+
+ const unsigned set_total_blocks32 = (bm::set_array_size32 * bm::set_array_size32);
++const unsigned set_sub_total_bits = bm::set_sub_array_size * bm::gap_max_bits;
+
+ #ifdef BM64ADDR
+ const unsigned set_total_blocks48 = bm::id_max48 / bm::gap_max_bits;
+ const unsigned long long id_max = bm::id_max48;
+-const unsigned long long set_array_size48 = 1 + (bm::id_max48 / (bm::set_sub_array_size * bm::gap_max_bits));
++const unsigned long long set_array_size48 = 1 + (bm::id_max48 / set_sub_total_bits);
+ const unsigned set_top_array_size = bm::set_array_size48;
+ const id64_t set_total_blocks = id64_t(bm::set_top_array_size) * set_sub_array_size;
+-//bm::id_max / (bm::gap_max_bits * bm::set_sub_array_size);
+ #else
+ const unsigned id_max = bm::id_max32;
+ const unsigned set_top_array_size = bm::set_array_size32;
+@@ -228,8 +228,8 @@
+ };
+
+ template<bool T> const char _copyright<T>::_p[] =
+- "BitMagic C++ Library. v.6.0.0 (c) 2002-2020 Anatoliy Kuznetsov.";
+-template<bool T> const unsigned _copyright<T>::_v[3] = {6, 0, 0};
++ "BitMagic C++ Library. v.6.4.0 (c) 2002-2020 Anatoliy Kuznetsov.";
++template<bool T> const unsigned _copyright<T>::_v[3] = {6, 4, 0};
+
+
+
+Index: c++/include/util/bitset/bmsse_util.h
+===================================================================
+--- a/c++/include/util/bitset/bmsse_util.h (revision 90103)
++++ b/c++/include/util/bitset/bmsse_util.h (revision 90104)
+@@ -823,9 +823,6 @@
+ inline
+ void sse2_invert_block(__m128i* dst)
+ {
+- //__m128i mZ = _mm_setzero_si128();
+- //__m128i maskF = _mm_cmpeq_epi8(mZ, mZ); // 0xFF..
+-
+ __m128i maskF = _mm_set1_epi32(~0u);
+ __m128i* BMRESTRICT dst_end =
+ (__m128i*)((bm::word_t*)(dst) + bm::set_block_size);
+Index: c++/include/util/bitset/bmsparsevec_util.h
+===================================================================
+--- a/c++/include/util/bitset/bmsparsevec_util.h (revision 90103)
++++ b/c++/include/util/bitset/bmsparsevec_util.h (revision 90104)
+@@ -70,7 +70,7 @@
+ /*!
+ \brief Move content from the argument address resolver
+ */
+- void move_from(bvps_addr_resolver& addr_res) BMNOEXEPT;
++ void move_from(bvps_addr_resolver& addr_res) BMNOEXCEPT;
+
+ /*!
+ \brief Resolve id to integer id (address)
+@@ -82,7 +82,7 @@
+
+ \return true if id is known and resolved successfully
+ */
+- bool resolve(size_type id_from, size_type* id_to) const;
++ bool resolve(size_type id_from, size_type* id_to) const BMNOEXCEPT;
+
+ /*!
+ \brief Resolve id to integer id (address) without sync check
+@@ -94,7 +94,7 @@
+
+ \return true if id is known and resolved successfully
+ */
+- bool get(size_type id_from, size_type* id_to) const;
++ bool get(size_type id_from, size_type* id_to) const BMNOEXCEPT;
+
+ /*!
+ \brief Set id (bit) to address resolver
+@@ -146,7 +146,7 @@
+ /*!
+ \brief equality comparison
+ */
+- bool equal(const bvps_addr_resolver& addr_res) const;
++ bool equal(const bvps_addr_resolver& addr_res) const BMNOEXCEPT;
+
+ protected:
+ void construct_rs_index();
+@@ -437,7 +437,7 @@
+
+
+ template<class BV>
+-void bvps_addr_resolver<BV>::move_from(bvps_addr_resolver& addr_res) BMNOEXEPT
++void bvps_addr_resolver<BV>::move_from(bvps_addr_resolver& addr_res) BMNOEXCEPT
+ {
+ if (this != &addr_res)
+ {
+@@ -459,7 +459,8 @@
+ //---------------------------------------------------------------------
+
+ template<class BV>
+-bool bvps_addr_resolver<BV>::resolve(size_type id_from, size_type* id_to) const
++bool bvps_addr_resolver<BV>::resolve(size_type id_from,
++ size_type* id_to) const BMNOEXCEPT
+ {
+ BM_ASSERT(id_to);
+ if (in_sync_)
+@@ -484,7 +485,8 @@
+ //---------------------------------------------------------------------
+
+ template<class BV>
+-bool bvps_addr_resolver<BV>::get(size_type id_from, size_type* id_to) const
++bool bvps_addr_resolver<BV>::get(size_type id_from,
++ size_type* id_to) const BMNOEXCEPT
+ {
+ BM_ASSERT(id_to);
+ BM_ASSERT(in_sync_);
+@@ -529,10 +531,10 @@
+ //---------------------------------------------------------------------
+
+ template<class BV>
+-bool bvps_addr_resolver<BV>::equal(const bvps_addr_resolver& addr_res) const
++bool bvps_addr_resolver<BV>::equal(
++ const bvps_addr_resolver& addr_res) const BMNOEXCEPT
+ {
+- int cmp = addr_bv_.compare(addr_res.addr_bv_);
+- return (cmp == 0);
++ return addr_bv_.equal(addr_res.addr_bv_);
+ }
+
+ //---------------------------------------------------------------------
+Index: c++/include/util/bitset/bmalloc.h
+===================================================================
+--- a/c++/include/util/bitset/bmalloc.h (revision 90103)
++++ b/c++/include/util/bitset/bmalloc.h (revision 90104)
+@@ -73,13 +73,10 @@
+ ptr = (bm::word_t*) ::_mm_malloc(n * sizeof(bm::word_t), BM_ALLOC_ALIGN);
+ #endif
+ #else
+- ptr = (bm::word_t*) ::malloc(n * sizeof(bm::word_t));
++ ptr = (bm::word_t*) ::malloc(n * sizeof(bm::word_t));
+ #endif
+-
+ if (!ptr)
+- {
+ throw std::bad_alloc();
+- }
+ return ptr;
+ }
+
+@@ -87,7 +84,7 @@
+ The member function frees storage for an array of n bm::word_t
+ elements, by calling free.
+ */
+- static void deallocate(bm::word_t* p, size_t)
++ static void deallocate(bm::word_t* p, size_t) BMNOEXCEPT
+ {
+ #ifdef BM_ALLOC_ALIGN
+ # ifdef _MSC_VER
+@@ -120,9 +117,7 @@
+ {
+ void* ptr = ::malloc(n * sizeof(void*));
+ if (!ptr)
+- {
+ throw std::bad_alloc();
+- }
+ return ptr;
+ }
+
+@@ -130,7 +125,7 @@
+ The member function frees storage for an array of n bm::word_t
+ elements, by calling free.
+ */
+- static void deallocate(void* p, size_t)
++ static void deallocate(void* p, size_t) BMNOEXCEPT
+ {
+ ::free(p);
+ }
+@@ -147,7 +142,7 @@
+ n_pool_max_size = BM_DEFAULT_POOL_SIZE
+ };
+
+- pointer_pool_array() : size_(0)
++ pointer_pool_array() : pool_ptr_(0), size_(0)
+ {
+ allocate_pool(n_pool_max_size);
+ }
+@@ -164,7 +159,7 @@
+ /// Push pointer to the pool (if it is not full)
+ ///
+ /// @return 0 if pointer is not accepted (pool is full)
+- unsigned push(void* ptr)
++ unsigned push(void* ptr) BMNOEXCEPT
+ {
+ if (size_ == n_pool_max_size - 1)
+ return 0;
+@@ -174,9 +169,9 @@
+
+ /// Get a pointer if there are any vacant
+ ///
+- void* pop()
++ void* pop() BMNOEXCEPT
+ {
+- if (size_ == 0)
++ if (!size_)
+ return 0;
+ return pool_ptr_[--size_];
+ }
+@@ -183,12 +178,13 @@
+ private:
+ void allocate_pool(size_t pool_size)
+ {
++ BM_ASSERT(!pool_ptr_);
+ pool_ptr_ = (void**)::malloc(sizeof(void*) * pool_size);
+ if (!pool_ptr_)
+ throw std::bad_alloc();
+ }
+
+- void free_pool()
++ void free_pool() BMNOEXCEPT
+ {
+ ::free(pool_ptr_);
+ }
+@@ -218,21 +214,19 @@
+ bm::word_t* alloc_bit_block()
+ {
+ bm::word_t* ptr = (bm::word_t*)block_pool_.pop();
+- if (ptr == 0)
++ if (!ptr)
+ ptr = block_alloc_.allocate(bm::set_block_size, 0);
+ return ptr;
+ }
+
+- void free_bit_block(bm::word_t* block)
++ void free_bit_block(bm::word_t* block) BMNOEXCEPT
+ {
+ BM_ASSERT(IS_VALID_ADDR(block));
+ if (!block_pool_.push(block))
+- {
+ block_alloc_.deallocate(block, bm::set_block_size);
+- }
+ }
+
+- void free_pools()
++ void free_pools() BMNOEXCEPT
+ {
+ bm::word_t* block;
+ do
+@@ -267,19 +261,19 @@
+
+ public:
+
+- mem_alloc(const BA& block_alloc = BA(), const PA& ptr_alloc = PA())
++ mem_alloc(const BA& block_alloc = BA(), const PA& ptr_alloc = PA()) BMNOEXCEPT
+ : block_alloc_(block_alloc),
+ ptr_alloc_(ptr_alloc),
+ alloc_pool_p_(0)
+ {}
+
+- mem_alloc(const mem_alloc& ma)
++ mem_alloc(const mem_alloc& ma) BMNOEXCEPT
+ : block_alloc_(ma.block_alloc_),
+ ptr_alloc_(ma.ptr_alloc_),
+ alloc_pool_p_(0) // do not inherit pool (has to be explicitly defined)
+ {}
+
+- mem_alloc& operator=(const mem_alloc& ma)
++ mem_alloc& operator=(const mem_alloc& ma) BMNOEXCEPT
+ {
+ block_alloc_ = ma.block_alloc_;
+ ptr_alloc_ = ma.ptr_alloc_;
+@@ -289,7 +283,7 @@
+
+ /*! @brief Returns copy of the block allocator object
+ */
+- block_allocator_type get_block_allocator() const
++ block_allocator_type get_block_allocator() const BMNOEXCEPT
+ {
+ return BA(block_alloc_);
+ }
+@@ -296,19 +290,19 @@
+
+ /*! @brief Returns copy of the ptr allocator object
+ */
+- ptr_allocator_type get_ptr_allocator() const
++ ptr_allocator_type get_ptr_allocator() const BMNOEXCEPT
+ {
+ return PA(block_alloc_);
+ }
+
+ /*! @brief set pointer to external pool */
+- void set_pool(allocator_pool_type* pool)
++ void set_pool(allocator_pool_type* pool) BMNOEXCEPT
+ {
+ alloc_pool_p_ = pool;
+ }
+
+ /*! @brief get pointer to allocation pool (if set) */
+- allocator_pool_type* get_pool()
++ allocator_pool_type* get_pool() BMNOEXCEPT
+ {
+ return alloc_pool_p_;
+ }
+@@ -328,7 +322,7 @@
+
+ /*! @brief Frees bit block allocated by alloc_bit_block.
+ */
+- void free_bit_block(bm::word_t* block, unsigned alloc_factor = 1)
++ void free_bit_block(bm::word_t* block, unsigned alloc_factor = 1) BMNOEXCEPT
+ {
+ BM_ASSERT(IS_VALID_ADDR(block));
+ if (alloc_pool_p_ && alloc_factor == 1)
+@@ -377,7 +371,7 @@
+
+ /*! @brief Frees block of pointers.
+ */
+- void free_ptr(void* p, size_t size)
++ void free_ptr(void* p, size_t size) BMNOEXCEPT
+ {
+ if (p)
+ ptr_alloc_.deallocate(p, size);
+@@ -427,7 +421,7 @@
+ ///
+ /// @internal
+ inline
+-void aligned_free(void* ptr)
++void aligned_free(void* ptr) BMNOEXCEPT
+ {
+ if (!ptr)
+ return;
+Index: c++/include/util/bitset/bmsparsevec_serial.h
+===================================================================
+--- a/c++/include/util/bitset/bmsparsevec_serial.h (revision 90103)
++++ b/c++/include/util/bitset/bmsparsevec_serial.h (revision 90104)
+@@ -927,7 +927,8 @@
+
+ BM_ASSERT(h1 == 'B' && (h2 == 'M' || h2 == 'C'));
+
+- if (h1 != 'B' && (h2 != 'M' || h2 != 'C')) // no magic header?
++ bool sig2_ok = (h2 == 'M' || h2 == 'C');
++ if (h1 != 'B' || !sig2_ok) //&& (h2 != 'M' || h2 != 'C')) // no magic header?
+ raise_invalid_header();
+
+ unsigned char bv_bo = dec.get_8(); (void) bv_bo;
+Index: c++/include/util/bitset/bmfunc.h
+===================================================================
+--- a/c++/include/util/bitset/bmfunc.h (revision 90103)
++++ b/c++/include/util/bitset/bmfunc.h (revision 90104)
+@@ -39,12 +39,12 @@
+ inline
+ bm::id_t bit_block_calc_count_range(const bm::word_t* block,
+ bm::word_t left,
+- bm::word_t right);
++ bm::word_t right) BMNOEXCEPT;
+
+ inline
+ bm::id_t bit_block_any_range(const bm::word_t* block,
+ bm::word_t left,
+- bm::word_t right);
++ bm::word_t right) BMNOEXCEPT;
+
+ /*!
+ @brief Structure with statistical information about memory
+@@ -64,7 +64,7 @@
+ unsigned long long gaps_by_level[bm::gap_levels]; ///< number of GAP blocks at each level
+
+ /// cound bit block
+- void add_bit_block()
++ void add_bit_block() BMNOEXCEPT
+ {
+ ++bit_blocks;
+ size_t mem_used = sizeof(bm::word_t) * bm::set_block_size;
+@@ -73,7 +73,7 @@
+ }
+
+ /// count gap block
+- void add_gap_block(unsigned capacity, unsigned length)
++ void add_gap_block(unsigned capacity, unsigned length) BMNOEXCEPT
+ {
+ ++gap_blocks;
+ size_t mem_used = (capacity * sizeof(gap_word_t));
+@@ -93,7 +93,7 @@
+ }
+
+ /// Reset statisctics
+- void reset()
++ void reset() BMNOEXCEPT
+ {
+ bit_blocks = gap_blocks = ptr_sub_blocks = bv_count = 0;
+ max_serialize_mem = memory_used = gap_cap_overhead = 0;
+@@ -102,10 +102,11 @@
+ }
+
+ /// Sum data from another sttructure
+- void add(const bv_statistics& st)
++ void add(const bv_statistics& st) BMNOEXCEPT
+ {
+ bit_blocks += st.bit_blocks;
+ gap_blocks += st.gap_blocks;
++ ptr_sub_blocks += st.ptr_sub_blocks;
+ bv_count += st.bv_count;
+ max_serialize_mem += st.max_serialize_mem + 8;
+ memory_used += st.memory_used;
+@@ -121,6 +122,8 @@
+ {
+ First first;
+ Second second;
++
++ pair(First f, Second s) : first(f), second(s) {}
+ };
+
+ /**
+@@ -141,7 +144,8 @@
+ \internal
+ */
+ template<typename BI_TYPE>
+-void get_block_coord(BI_TYPE nb, unsigned& i, unsigned& j)
++BMFORCEINLINE
++void get_block_coord(BI_TYPE nb, unsigned& i, unsigned& j) BMNOEXCEPT
+ {
+ i = unsigned(nb >> bm::set_array_shift); // top block address
+ j = unsigned(nb & bm::set_array_mask); // address in sub-block
+@@ -148,18 +152,28 @@
+ }
+
+ /**
+- \brief ad-hoc conditional expressions
++ Compute bit address of the first bit in a superblock
+ \internal
+ */
+-template <bool b> struct conditional
++template<typename RTYPE>
++BMFORCEINLINE RTYPE get_super_block_start(unsigned i) BMNOEXCEPT
+ {
+- static bool test() { return true; }
+-};
+-template <> struct conditional<false>
++ return RTYPE(i) * bm::set_sub_total_bits;
++}
++
++/**
++ Compute bit address of the first bit in a block
++ \internal
++*/
++template<typename RTYPE>
++BMFORCEINLINE RTYPE get_block_start(unsigned i, unsigned j) BMNOEXCEPT
+ {
+- static bool test() { return false; }
+-};
++ RTYPE idx = bm::get_super_block_start<RTYPE>(i);
++ idx += (j) * bm::gap_max_bits;
++ return idx;
++}
+
++
+ /*!
+ @defgroup gapfunc GAP functions
+ GAP functions implement different opereations on GAP compressed blocks (internals)
+@@ -177,42 +191,12 @@
+ */
+
+
+-
+-
+ /*!
+- Returns BSR value
+- @ingroup bitfunc
+-*/
+-template <class T>
+-unsigned bit_scan_reverse(T value)
+-{
+- BM_ASSERT(value);
+-
+- if (bm::conditional<sizeof(T)==8>::test())
+- {
+- #if defined(BM_USE_GCC_BUILD)
+- return (unsigned) (63 - __builtin_clzll(value));
+- #else
+- bm::id64_t v8 = value;
+- v8 >>= 32;
+- unsigned v = (unsigned)v8;
+- if (v)
+- {
+- v = bm::bit_scan_reverse32(v);
+- return v + 32;
+- }
+- #endif
+- }
+- return bit_scan_reverse32((unsigned)value);
+-}
+-
+-
+-/*!
+ Returns bit count
+ @ingroup bitfunc
+ */
+ BMFORCEINLINE
+-bm::id_t word_bitcount(bm::id_t w)
++bm::id_t word_bitcount(bm::id_t w) BMNOEXCEPT
+ {
+ #if defined(BMSSE42OPT) || defined(BMAVX2OPT)
+ return bm::id_t(_mm_popcnt_u32(w));
+@@ -230,7 +214,7 @@
+ }
+
+ inline
+-int parallel_popcnt_32(unsigned int n)
++int parallel_popcnt_32(unsigned int n) BMNOEXCEPT
+ {
+ unsigned int tmp;
+
+@@ -245,7 +229,7 @@
+ @ingroup bitfunc
+ */
+ BMFORCEINLINE
+-unsigned word_bitcount64(bm::id64_t x)
++unsigned word_bitcount64(bm::id64_t x) BMNOEXCEPT
+ {
+ #if defined(BMSSE42OPT) || defined(BMAVX2OPT)
+ #if defined(BM64_SSE4) || defined(BM64_AVX2) || defined(BM64_AVX512)
+@@ -270,7 +254,7 @@
+
+ inline
+ unsigned bitcount64_4way(bm::id64_t x, bm::id64_t y,
+- bm::id64_t u, bm::id64_t v)
++ bm::id64_t u, bm::id64_t v) BMNOEXCEPT
+ {
+ const bm::id64_t m1 = 0x5555555555555555U;
+ const bm::id64_t m2 = 0x3333333333333333U;
+@@ -400,7 +384,8 @@
+ /*! @brief Adaptor to copy 1 bits to array
+ @internal
+ */
+-template<typename B> class copy_to_array_functor
++template<typename B>
++class copy_to_array_functor
+ {
+ public:
+ copy_to_array_functor(B* bits): bp_(bits)
+@@ -408,10 +393,10 @@
+
+ B* ptr() { return bp_; }
+
+- void operator()(unsigned bit_idx) { *bp_++ = (B)bit_idx; }
++ void operator()(unsigned bit_idx) BMNOEXCEPT { *bp_++ = (B)bit_idx; }
+
+ void operator()(unsigned bit_idx0,
+- unsigned bit_idx1)
++ unsigned bit_idx1) BMNOEXCEPT
+ {
+ bp_[0] = (B)bit_idx0; bp_[1] = (B)bit_idx1;
+ bp_+=2;
+@@ -419,7 +404,7 @@
+
+ void operator()(unsigned bit_idx0,
+ unsigned bit_idx1,
+- unsigned bit_idx2)
++ unsigned bit_idx2) BMNOEXCEPT
+ {
+ bp_[0] = (B)bit_idx0; bp_[1] = (B)bit_idx1; bp_[2] = (B)bit_idx2;
+ bp_+=3;
+@@ -428,7 +413,7 @@
+ void operator()(unsigned bit_idx0,
+ unsigned bit_idx1,
+ unsigned bit_idx2,
+- unsigned bit_idx3)
++ unsigned bit_idx3) BMNOEXCEPT
+ {
+ bp_[0] = (B)bit_idx0; bp_[1] = (B)bit_idx1;
+ bp_[2] = (B)bit_idx2; bp_[3] = (B)bit_idx3;
+@@ -451,7 +436,8 @@
+
+ @ingroup bitfunc
+ */
+-template<typename T,typename B> unsigned bit_list(T w, B* bits)
++template<typename T,typename B>
++unsigned bit_list(T w, B* bits) BMNOEXCEPT
+ {
+ copy_to_array_functor<B> func(bits);
+ bit_for_each(w, func);
+@@ -468,7 +454,8 @@
+
+ @ingroup bitfunc
+ */
+-template<typename T,typename B> unsigned bit_list_4(T w, B* bits)
++template<typename T,typename B>
++unsigned bit_list_4(T w, B* bits) BMNOEXCEPT
+ {
+ copy_to_array_functor<B> func(bits);
+ bit_for_each_4(w, func);
+@@ -486,7 +473,8 @@
+ @internal
+ */
+ template<typename B>
+-unsigned short bitscan_popcnt(bm::id_t w, B* bits, unsigned short offs)
++unsigned short
++bitscan_popcnt(bm::id_t w, B* bits, unsigned short offs) BMNOEXCEPT
+ {
+ unsigned pos = 0;
+ while (w)
+@@ -508,7 +496,7 @@
+ @internal
+ */
+ template<typename B>
+-unsigned short bitscan_popcnt(bm::id_t w, B* bits)
++unsigned short bitscan_popcnt(bm::id_t w, B* bits) BMNOEXCEPT
+ {
+ unsigned pos = 0;
+ while (w)
+@@ -529,29 +517,48 @@
+ @ingroup bitfunc
+ */
+ template<typename B>
+-unsigned short bitscan_popcnt64(bm::id64_t w, B* bits)
++unsigned short bitscan_popcnt64(bm::id64_t w, B* bits) BMNOEXCEPT
+ {
+ unsigned short pos = 0;
+ while (w)
+ {
+- bm::id64_t t = w & -w;
++ bm::id64_t t = bmi_blsi_u64(w); // w & -w;
+ bits[pos++] = (B) bm::word_bitcount64(t - 1);
+- w &= w - 1;
++ w = bmi_bslr_u64(w); // w &= w - 1;
+ }
+ return pos;
+ }
+
++/*!
++ \brief Unpacks 64-bit word into list of ON bit indexes using popcnt method
++ \param w - value
++ \param bits - pointer on the result array
++ \param offs - value to add to bit position (programmed shift)
++ \return number of bits in the list
++ @ingroup bitfunc
++*/
++template<typename B>
++unsigned short
++bitscan_popcnt64(bm::id64_t w, B* bits, unsigned short offs) BMNOEXCEPT
++{
++ unsigned short pos = 0;
++ while (w)
++ {
++ bm::id64_t t = bmi_blsi_u64(w); // w & -w;
++ bits[pos++] = B(bm::word_bitcount64(t - 1) + offs);
++ w = bmi_bslr_u64(w); // w &= w - 1;
++ }
++ return pos;
++}
++
++
+ template<typename V, typename B>
+-unsigned short bitscan(V w, B* bits)
++unsigned short bitscan(V w, B* bits) BMNOEXCEPT
+ {
+ if (bm::conditional<sizeof(V) == 8>::test())
+- {
+ return bm::bitscan_popcnt64(w, bits);
+- }
+ else
+- {
+ return bm::bitscan_popcnt((bm::word_t)w, bits);
+- }
+ }
+
+ // --------------------------------------------------------------
+@@ -566,7 +573,7 @@
+ \return selected value (inxed of bit set)
+ */
+ inline
+-unsigned word_select64_linear(bm::id64_t w, unsigned rank)
++unsigned word_select64_linear(bm::id64_t w, unsigned rank) BMNOEXCEPT
+ {
+ BM_ASSERT(w);
+ BM_ASSERT(rank);
+@@ -589,7 +596,7 @@
+ \return selected value (inxed of bit set)
+ */
+ inline
+-unsigned word_select64_bitscan(bm::id64_t w, unsigned rank)
++unsigned word_select64_bitscan(bm::id64_t w, unsigned rank) BMNOEXCEPT
+ {
+ BM_ASSERT(w);
+ BM_ASSERT(rank);
+@@ -616,7 +623,7 @@
+ \return selected value (inxed of bit set)
+ */
+ inline
+-unsigned word_select64(bm::id64_t w, unsigned rank)
++unsigned word_select64(bm::id64_t w, unsigned rank) BMNOEXCEPT
+ {
+ #if defined(BMI2_SELECT64)
+ return BMI2_SELECT64(w, rank);
+@@ -642,7 +649,7 @@
+ @internal
+ */
+ BMFORCEINLINE
+-bm::id64_t widx_to_digest_mask(unsigned w_idx)
++bm::id64_t widx_to_digest_mask(unsigned w_idx) BMNOEXCEPT
+ {
+ bm::id64_t mask(1ull);
+ return mask << (w_idx / bm::set_block_digest_wave_size);
+@@ -657,7 +664,7 @@
+ @internal
+ */
+ BMFORCEINLINE
+-bm::id64_t digest_mask(unsigned from, unsigned to)
++bm::id64_t digest_mask(unsigned from, unsigned to) BMNOEXCEPT
+ {
+ BM_ASSERT(from <= to);
+
+@@ -680,7 +687,8 @@
+ @internal
+ */
+ inline
+-bool check_zero_digest(bm::id64_t digest, unsigned bitpos_from, unsigned bitpos_to)
++bool check_zero_digest(bm::id64_t digest,
++ unsigned bitpos_from, unsigned bitpos_to) BMNOEXCEPT
+ {
+ bm::id64_t mask = bm::digest_mask(bitpos_from, bitpos_to);
+ return !(digest & mask);
+@@ -695,7 +703,7 @@
+ @internal
+ */
+ inline
+-void block_init_digest0(bm::word_t* const block, bm::id64_t digest)
++void block_init_digest0(bm::word_t* const block, bm::id64_t digest) BMNOEXCEPT
+ {
+ unsigned off;
+ for (unsigned i = 0; i < 64; ++i)
+@@ -725,7 +733,7 @@
+ @internal
+ */
+ inline
+-bm::id64_t calc_block_digest0(const bm::word_t* const block)
++bm::id64_t calc_block_digest0(const bm::word_t* const block) BMNOEXCEPT
+ {
+ bm::id64_t digest0 = 0;
+ unsigned off;
+@@ -766,7 +774,8 @@
+ @internal
+ */
+ inline
+-bm::id64_t update_block_digest0(const bm::word_t* const block, bm::id64_t digest)
++bm::id64_t
++update_block_digest0(const bm::word_t* const block, bm::id64_t digest) BMNOEXCEPT
+ {
+ const bm::id64_t mask(1ull);
+ bm::id64_t d = digest;
+@@ -807,7 +816,7 @@
+
+ /// Returns true if set operation is constant (bitcount)
+ inline
+-bool is_const_set_operation(set_operation op)
++bool is_const_set_operation(set_operation op) BMNOEXCEPT
+ {
+ return (int(op) >= int(set_COUNT));
+ }
+@@ -816,7 +825,7 @@
+ Convert set operation to operation
+ */
+ inline
+-bm::operation setop2op(bm::set_operation op)
++bm::operation setop2op(bm::set_operation op) BMNOEXCEPT
+ {
+ BM_ASSERT(op == set_AND ||
+ op == set_OR ||
+@@ -863,7 +872,7 @@
+ // version with minimal branching, super-scalar friendly
+ //
+ inline
+- static bm::id64_t block_type(const bm::word_t* bp)
++ static bm::id64_t block_type(const bm::word_t* bp) BMNOEXCEPT
+ {
+ bm::id64_t type;
+ if (bm::conditional<sizeof(void*) == 8>::test())
+@@ -884,11 +893,11 @@
+ }
+
+ BMFORCEINLINE
+- static bool is_full_block(const bm::word_t* bp)
++ static bool is_full_block(const bm::word_t* bp) BMNOEXCEPT
+ { return (bp == _block._p || bp == _block._p_fullp); }
+
+ BMFORCEINLINE
+- static bool is_valid_block_addr(const bm::word_t* bp)
++ static bool is_valid_block_addr(const bm::word_t* bp) BMNOEXCEPT
+ { return (bp && !(bp == _block._p || bp == _block._p_fullp)); }
+
+ static all_set_block _block;
+@@ -899,7 +908,7 @@
+
+ /// XOR swap two scalar variables
+ template<typename W>
+-void xor_swap(W& x, W& y)
++void xor_swap(W& x, W& y) BMNOEXCEPT
+ {
+ BM_ASSERT(&x != &y);
+ x ^= y;
+@@ -913,7 +922,7 @@
+ @internal
+ */
+ template<typename N>
+-bool find_not_null_ptr(bm::word_t*** arr, N start, N size, N* pos)
++bool find_not_null_ptr(bm::word_t*** arr, N start, N size, N* pos) BMNOEXCEPT
+ {
+ BM_ASSERT(pos);
+ // BM_ASSERT(start < size);
+@@ -1035,7 +1044,7 @@
+ @ingroup bitfunc
+ */
+ inline
+-bool bit_is_all_zero(const bm::word_t* BMRESTRICT start)
++bool bit_is_all_zero(const bm::word_t* BMRESTRICT start) BMNOEXCEPT
+ {
+ #if defined(VECT_IS_ZERO_BLOCK)
+ return VECT_IS_ZERO_BLOCK(start);
+@@ -1062,7 +1071,7 @@
+ @ingroup gapfunc
+ */
+ BMFORCEINLINE
+-bool gap_is_all_zero(const bm::gap_word_t* buf)
++bool gap_is_all_zero(const bm::gap_word_t* BMRESTRICT buf) BMNOEXCEPT
+ {
+ // (almost) branchless variant:
+ return (!(*buf & 1u)) & (!(bm::gap_max_bits - 1 - buf[1]));
+@@ -1075,7 +1084,7 @@
+ @ingroup gapfunc
+ */
+ BMFORCEINLINE
+-bool gap_is_all_one(const bm::gap_word_t* buf)
++bool gap_is_all_one(const bm::gap_word_t* BMRESTRICT buf) BMNOEXCEPT
+ {
+ return ((*buf & 1u) && (buf[1] == bm::gap_max_bits - 1));
+ }
+@@ -1088,7 +1097,7 @@
+ @ingroup gapfunc
+ */
+ BMFORCEINLINE
+-bm::gap_word_t gap_length(const bm::gap_word_t* buf)
++bm::gap_word_t gap_length(const bm::gap_word_t* BMRESTRICT buf) BMNOEXCEPT
+ {
+ return (bm::gap_word_t)((*buf >> 3) + 1);
+ }
+@@ -1103,7 +1112,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-unsigned gap_capacity(const T* buf, const T* glevel_len)
++unsigned
++gap_capacity(const T* BMRESTRICT buf, const T* BMRESTRICT glevel_len) BMNOEXCEPT
+ {
+ return glevel_len[(*buf >> 1) & 3];
+ }
+@@ -1118,7 +1128,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-unsigned gap_limit(const T* buf, const T* glevel_len)
++unsigned
++gap_limit(const T* BMRESTRICT buf, const T* BMRESTRICT glevel_len) BMNOEXCEPT
+ {
+ return glevel_len[(*buf >> 1) & 3]-4;
+ }
+@@ -1132,7 +1143,7 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-T gap_level(const T* buf)
++T gap_level(const T* BMRESTRICT buf) BMNOEXCEPT
+ {
+ return T((*buf >> 1) & 3u);
+ }
+@@ -1149,7 +1160,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-unsigned gap_find_last(const T* buf, unsigned* last)
++unsigned
++gap_find_last(const T* BMRESTRICT buf, unsigned* BMRESTRICT last) BMNOEXCEPT
+ {
+ BM_ASSERT(last);
+
+@@ -1179,7 +1191,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-unsigned gap_find_first(const T* buf, unsigned* first)
++unsigned
++gap_find_first(const T* BMRESTRICT buf, unsigned* BMRESTRICT first) BMNOEXCEPT
+ {
+ BM_ASSERT(first);
+
+@@ -1206,24 +1219,30 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-unsigned gap_bfind(const T* buf, unsigned pos, unsigned* is_set)
++unsigned gap_bfind(const T* BMRESTRICT buf,
++ unsigned pos, unsigned* BMRESTRICT is_set) BMNOEXCEPT
+ {
+ BM_ASSERT(pos < bm::gap_max_bits);
+- *is_set = (*buf) & 1;
++ #undef VECT_GAP_BFIND // TODO: VECTOR bfind causes performance degradation
++ #ifdef VECT_GAP_BFIND
++ return VECT_GAP_BFIND(buf, pos, is_set);
++ #else
++ *is_set = (*buf) & 1;
+
+- unsigned start = 1;
+- unsigned end = 1 + ((*buf) >> 3);
++ unsigned start = 1;
++ unsigned end = 1 + ((*buf) >> 3);
+
+- while ( start != end )
+- {
+- unsigned curr = (start + end) >> 1;
+- if ( buf[curr] < pos )
+- start = curr + 1;
+- else
+- end = curr;
+- }
+- *is_set ^= ((start-1) & 1);
+- return start;
++ while ( start != end )
++ {
++ unsigned curr = (start + end) >> 1;
++ if ( buf[curr] < pos )
++ start = curr + 1;
++ else
++ end = curr;
++ }
++ *is_set ^= ((start-1) & 1);
++ return start;
++ #endif
+ }
+
+
+@@ -1234,7 +1253,8 @@
+ \return true if position is in "1" gap
+ @ingroup gapfunc
+ */
+-template<typename T> unsigned gap_test(const T* buf, unsigned pos)
++template<typename T>
++unsigned gap_test(const T* BMRESTRICT buf, unsigned pos) BMNOEXCEPT
+ {
+ BM_ASSERT(pos < bm::gap_max_bits);
+
+@@ -1277,7 +1297,7 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-unsigned gap_test_unr(const T* buf, const unsigned pos)
++unsigned gap_test_unr(const T* BMRESTRICT buf, const unsigned pos) BMNOEXCEPT
+ {
+ BM_ASSERT(pos < bm::gap_max_bits);
+
+@@ -1286,84 +1306,10 @@
+ return (*buf) & 1;
+ }
+ #if defined(BMSSE2OPT)
+- unsigned start = 1;
+- unsigned end = 1 + ((*buf) >> 3);
+- unsigned dsize = end - start;
+-
+- if (dsize < 17)
+- {
+- start = bm::sse2_gap_find(buf + 1, (bm::gap_word_t)pos, dsize);
+- unsigned res = ((*buf) & 1) ^ ((start) & 1);
+- BM_ASSERT(buf[start + 1] >= pos);
+- BM_ASSERT(buf[start] < pos || (start == 0));
+- BM_ASSERT(res == bm::gap_test(buf, pos));
+- return res;
+- }
+- unsigned arr_end = end;
+- while (start != end)
+- {
+- unsigned curr = (start + end) >> 1;
+- if (buf[curr] < pos)
+- start = curr + 1;
+- else
+- end = curr;
+-
+- unsigned size = end - start;
+- if (size < 16)
+- {
+- size += (end != arr_end);
+- unsigned idx = bm::sse2_gap_find(buf + start, (bm::gap_word_t)pos, size);
+- start += idx;
+-
+- BM_ASSERT(buf[start] >= pos);
+- BM_ASSERT(buf[start - 1] < pos || (start == 1));
+- break;
+- }
+- }
+-
+- unsigned res = ((*buf) & 1) ^ ((--start) & 1);
+-
++ unsigned res = bm::sse2_gap_test(buf, pos);
+ BM_ASSERT(res == bm::gap_test(buf, pos));
+- return res;
+-//#endif
+ #elif defined(BMSSE42OPT)
+- unsigned start = 1;
+- unsigned end = 1 + ((*buf) >> 3);
+- unsigned dsize = end - start;
+-
+- if (dsize < 17)
+- {
+- start = bm::sse4_gap_find(buf+1, (bm::gap_word_t)pos, dsize);
+- unsigned res = ((*buf) & 1) ^ ((start) & 1);
+- BM_ASSERT(buf[start+1] >= pos);
+- BM_ASSERT(buf[start] < pos || (start==0));
+- BM_ASSERT(res == bm::gap_test(buf, pos));
+- return res;
+- }
+- unsigned arr_end = end;
+- while (start != end)
+- {
+- unsigned curr = (start + end) >> 1;
+- if (buf[curr] < pos)
+- start = curr + 1;
+- else
+- end = curr;
+-
+- unsigned size = end - start;
+- if (size < 16)
+- {
+- size += (end != arr_end);
+- unsigned idx = bm::sse4_gap_find(buf + start, (bm::gap_word_t)pos, size);
+- start += idx;
+-
+- BM_ASSERT(buf[start] >= pos);
+- BM_ASSERT(buf[start - 1] < pos || (start == 1));
+- break;
+- }
+- }
+-
+- unsigned res = ((*buf) & 1) ^ ((--start) & 1);
+-
++ unsigned res = bm::sse42_gap_test(buf, pos);
+ BM_ASSERT(res == bm::gap_test(buf, pos));
+ #elif defined(BMAVX2OPT)
+ unsigned res = bm::avx2_gap_test(buf, pos);
+@@ -1378,21 +1324,22 @@
+ \internal
+ */
+ template<typename T, typename N, typename F>
+-void for_each_nzblock_range(T*** root, N top_size, N nb_from, N nb_to, F& f)
++void for_each_nzblock_range(T*** root,
++ N top_size, N nb_from, N nb_to, F& f) BMNOEXCEPT
+ {
+ BM_ASSERT(top_size);
+ if (nb_from > nb_to)
+ return;
+- unsigned i_from = nb_from >> bm::set_array_shift;
+- unsigned j_from = nb_from & bm::set_array_mask;
+- unsigned i_to = nb_to >> bm::set_array_shift;
+- unsigned j_to = nb_to & bm::set_array_mask;
++ unsigned i_from = unsigned(nb_from >> bm::set_array_shift);
++ unsigned j_from = unsigned(nb_from & bm::set_array_mask);
++ unsigned i_to = unsigned(nb_to >> bm::set_array_shift);
++ unsigned j_to = unsigned(nb_to & bm::set_array_mask);
+
+ if (i_from >= top_size)
+ return;
+ if (i_to >= top_size)
+ {
+- i_to = top_size-1;
++ i_to = unsigned(top_size-1);
+ j_to = bm::set_sub_array_size-1;
+ }
+
+@@ -1400,16 +1347,12 @@
+ {
+ T** blk_blk = root[i];
+ if (!blk_blk)
+- {
+ continue;
+- }
+ if ((bm::word_t*)blk_blk == FULL_BLOCK_FAKE_ADDR)
+ {
+ unsigned j = (i == i_from) ? j_from : 0;
+ if (!j && (i != i_to)) // full sub-block
+- {
+- f.add_full(bm::set_sub_array_size * bm::gap_max_bits);
+- }
++ f.add_full(bm::set_sub_total_bits);
+ else
+ {
+ do
+@@ -1426,13 +1369,10 @@
+ do
+ {
+ if (blk_blk[j])
+- {
+ f(blk_blk[j]);
+- }
+ if ((i == i_to) && (j == j_to))
+ return;
+- ++j;
+- } while (j < bm::set_sub_array_size);
++ } while (++j < bm::set_sub_array_size);
+ }
+ } // for i
+ }
+@@ -1672,7 +1612,7 @@
+ Function returns if function-predicate returns true
+ */
+ template<typename T, typename BI, typename F>
+-bool for_each_nzblock_if(T*** root, BI size1, F& f)
++bool for_each_nzblock_if(T*** root, BI size1, F& f) BMNOEXCEPT
+ {
+ BI block_idx = 0;
+ for (BI i = 0; i < size1; ++i)
+@@ -1754,14 +1694,11 @@
+ /*! Computes SUM of all elements of the sequence
+ */
+ template<typename T>
+-bm::id64_t sum_arr(T* first, T* last)
++bm::id64_t sum_arr(const T* first, const T* last) BMNOEXCEPT
+ {
+ bm::id64_t sum = 0;
+- while (first < last)
+- {
++ for (;first < last; ++first)
+ sum += *first;
+- ++first;
+- }
+ return sum;
+ }
+
+@@ -1775,7 +1712,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-void gap_split(const T* buf, T* arr0, T* arr1, T& arr0_cnt, T& arr1_cnt)
++void gap_split(const T* buf,
++ T* arr0, T* arr1, T& arr0_cnt, T& arr1_cnt) BMNOEXCEPT
+ {
+ const T* pcurr = buf;
+ unsigned len = (*pcurr >> 3);
+@@ -1834,7 +1772,7 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-unsigned gap_bit_count(const T* buf, unsigned dsize=0)
++unsigned gap_bit_count(const T* buf, unsigned dsize=0) BMNOEXCEPT
+ {
+ const T* pcurr = buf;
+ if (dsize == 0)
+@@ -1850,14 +1788,8 @@
+ bits_counter += *pcurr + 1;
+ ++pcurr;
+ }
+- ++pcurr; // set GAP to 1
+-
+- while (pcurr <= pend)
+- {
++ for (++pcurr; pcurr <= pend; pcurr += 2)
+ bits_counter += *pcurr - *(pcurr-1);
+- pcurr += 2; // jump to the next positive GAP
+- }
+-
+ return bits_counter;
+ }
+
+@@ -1867,7 +1799,8 @@
+ \return Number of non-zero bits.
+ @ingroup gapfunc
+ */
+-template<typename T> unsigned gap_bit_count_unr(const T* buf)
++template<typename T>
++unsigned gap_bit_count_unr(const T* buf) BMNOEXCEPT
+ {
+ const T* pcurr = buf;
+ unsigned dsize = (*pcurr >> 3);
+@@ -1918,7 +1851,7 @@
+ {
+ cnt += *pcurr - *(pcurr - 1);
+ }
+- BM_ASSERT(cnt == gap_bit_count(buf));
++ BM_ASSERT(cnt == bm::gap_bit_count(buf));
+ return cnt;
+ }
+
+@@ -1933,9 +1866,11 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-unsigned gap_bit_count_range(const T* const buf, unsigned left, unsigned right)
++unsigned gap_bit_count_range(const T* const buf,
++ unsigned left, unsigned right) BMNOEXCEPT
+ {
+ BM_ASSERT(left <= right);
++ BM_ASSERT(right < bm::gap_max_bits);
+
+ const T* pcurr = buf;
+ const T* pend = pcurr + (*pcurr >> 3);
+@@ -1966,6 +1901,140 @@
+ }
+
+ /*!
++ \brief Test if all bits are 1 in GAP buffer in the [left, right] range.
++ \param buf - GAP buffer pointer.
++ \param left - leftmost bit index to start from
++ \param right- rightmost bit index
++ \return true if all bits are "11111"
++ @ingroup gapfunc
++*/
++template<typename T>
++bool gap_is_all_one_range(const T* const BMRESTRICT buf,
++ unsigned left, unsigned right) BMNOEXCEPT
++{
++ BM_ASSERT(left <= right);
++ BM_ASSERT(right < bm::gap_max_bits);
++
++ unsigned is_set;
++ unsigned start_pos = bm::gap_bfind(buf, left, &is_set);
++ if (!is_set) // GAP is 0
++ return false;
++ const T* const pcurr = buf + start_pos;
++ return (right <= *pcurr);
++}
++
++/*!
++ \brief Test if any bits are 1 in GAP buffer in the [left, right] range.
++ \param buf - GAP buffer pointer.
++ \param left - leftmost bit index to start from
++ \param right- rightmost bit index
++ \return true if at least 1 "00010"
++ @ingroup gapfunc
++*/
++template<typename T>
++bool gap_any_range(const T* const BMRESTRICT buf,
++ unsigned left, unsigned right) BMNOEXCEPT
++{
++ BM_ASSERT(left <= right);
++ BM_ASSERT(right < bm::gap_max_bits);
++
++ unsigned is_set;
++ unsigned start_pos = bm::gap_bfind(buf, left, &is_set);
++ const T* const pcurr = buf + start_pos;
++
++ if (!is_set) // start GAP is 0 ...
++ {
++ if (right <= *pcurr) // ...bit if the interval goes into at least 1 blk
++ return false; // .. nope
++ return true;
++ }
++ return true;
++}
++
++/*!
++ \brief Test if any bits are 1 in GAP buffer in the [left, right] range
++ and flanked with 0s
++ \param buf - GAP buffer pointer.
++ \param left - leftmost bit index to start from
++ \param right- rightmost bit index
++ \return true if "011110"
++ @ingroup gapfunc
++*/
++template<typename T>
++bool gap_is_interval(const T* const BMRESTRICT buf,
++ unsigned left, unsigned right) BMNOEXCEPT
++{
++ BM_ASSERT(left <= right);
++ BM_ASSERT(left > 0); // cannot check left-1 otherwise
++ BM_ASSERT(right < bm::gap_max_bits-1); // cannot check right+1 otherwise
++
++ unsigned is_set;
++ unsigned start_pos = bm::gap_bfind(buf, left, &is_set);
++
++ const T* pcurr = buf + start_pos;
++ if (!is_set || (right != *pcurr) || (start_pos <= 1))
++ return false;
++ --pcurr;
++ if (*pcurr != left-1)
++ return false;
++ return true;
++}
++
++/**
++ \brief Searches for the last 1 bit in the 111 interval of a GAP block
++ \param buf - BIT block buffer
++ \param nbit - bit index to start checking from
++ \param pos - [out] found value
++
++ \return false if not found
++ @ingroup gapfunc
++*/
++template<typename T>
++bool gap_find_interval_end(const T* const BMRESTRICT buf,
++ unsigned nbit, unsigned* BMRESTRICT pos) BMNOEXCEPT
++{
++ BM_ASSERT(pos);
++ BM_ASSERT(nbit < bm::gap_max_bits);
++
++ unsigned is_set;
++ unsigned start_pos = bm::gap_bfind(buf, nbit, &is_set);
++ if (!is_set)
++ return false;
++ *pos = buf[start_pos];
++ return true;
++}
++
++
++/**
++ \brief Searches for the first 1 bit in the 111 interval of a GAP block
++ \param buf - BIT block buffer
++ \param nbit - bit index to start checking from
++ \param pos - [out] found value
++
++ \return false if not found
++ @ingroup gapfunc
++*/
++template<typename T>
++bool gap_find_interval_start(const T* const BMRESTRICT buf,
++ unsigned nbit, unsigned* BMRESTRICT pos) BMNOEXCEPT
++{
++ BM_ASSERT(pos);
++ BM_ASSERT(nbit < bm::gap_max_bits);
++
++ unsigned is_set;
++ unsigned start_pos = bm::gap_bfind(buf, nbit, &is_set);
++ if (!is_set)
++ return false;
++ --start_pos;
++ if (!start_pos)
++ *pos = 0;
++ else
++ *pos = buf[start_pos]+1;
++ return true;
++}
++
++
++/*!
+ \brief GAP block find position for the rank
+
+ \param block - bit block buffer pointer
+@@ -1982,7 +2051,7 @@
+ SIZE_TYPE gap_find_rank(const T* const block,
+ SIZE_TYPE rank,
+ unsigned nbit_from,
+- unsigned& nbit_pos)
++ unsigned& nbit_pos) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+ BM_ASSERT(rank);
+@@ -2025,11 +2094,14 @@
+ \brief Counts 1 bits in GAP buffer in the closed [0, right] range.
+ \param buf - GAP buffer pointer.
+ \param right- rightmost bit index
+- \return Number of non-zero bits.
++ \param is_corrected - if true the result will be rank corrected
++ if right bit == true count=count-1
++ \return Number of non-zero bits
+ @ingroup gapfunc
+ */
+ template<typename T>
+-unsigned gap_bit_count_to(const T* const buf, T right)
++unsigned gap_bit_count_to(const T* const buf, T right,
++ bool is_corrected=false) BMNOEXCEPT
+ {
+ const T* pcurr = buf;
+ const T* pend = pcurr + (*pcurr >> 3);
+@@ -2042,6 +2114,7 @@
+ if (right <= *pcurr) // we are in the target block right now
+ {
+ bits_counter = (right + 1u) & is_set; // & is_set == if (is_set)
++ bits_counter -= (is_set & unsigned(is_corrected));
+ return bits_counter;
+ }
+ bits_counter += (*pcurr + 1u) & is_set;
+@@ -2051,10 +2124,14 @@
+ {
+ bits_counter += (*pcurr - prev_gap) & is_set;
+ if (pcurr == pend)
++ {
++ bits_counter -= (is_set & unsigned(is_corrected));
+ return bits_counter;
++ }
+ prev_gap = *pcurr++;
+ }
+ bits_counter += (right - prev_gap) & is_set;
++ bits_counter -= (is_set & unsigned(is_corrected));
+ return bits_counter;
+ }
+
+@@ -2110,7 +2187,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-T* gap_2_dgap(const T* gap_buf, T* dgap_buf, bool copy_head=true)
++T* gap_2_dgap(const T* BMRESTRICT gap_buf,
++ T* BMRESTRICT dgap_buf, bool copy_head=true) BMNOEXCEPT
+ {
+ if (copy_head) // copy GAP header
+ {
+@@ -2135,7 +2213,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-void dgap_2_gap(const T* dgap_buf, T* gap_buf, T gap_header=0)
++void dgap_2_gap(const T* BMRESTRICT dgap_buf,
++ T* BMRESTRICT gap_buf, T gap_header=0) BMNOEXCEPT
+ {
+ const T* pcurr = dgap_buf;
+ unsigned len;
+@@ -2175,7 +2254,8 @@
+
+ @ingroup gapfunc
+ */
+-template<typename T> int gapcmp(const T* buf1, const T* buf2)
++template<typename T>
++int gapcmp(const T* buf1, const T* buf2) BMNOEXCEPT
+ {
+ const T* pcurr1 = buf1;
+ const T* pend1 = pcurr1 + (*pcurr1 >> 3);
+@@ -2213,9 +2293,7 @@
+ return (bitval1) ? 1 : -1;
+ }
+ }
+-
+ ++pcurr1; ++pcurr2;
+-
+ bitval1 ^= 1;
+ bitval2 ^= 1;
+ }
+@@ -2235,7 +2313,7 @@
+ template<typename T>
+ bool gap_find_first_diff(const T* BMRESTRICT buf1,
+ const T* BMRESTRICT buf2,
+- unsigned* BMRESTRICT pos)
++ unsigned* BMRESTRICT pos) BMNOEXCEPT
+ {
+ BM_ASSERT(buf1 && buf2 && pos);
+
+@@ -2253,8 +2331,9 @@
+ return false;
+ }
+
++// -------------------------------------------------------------------------
++//
+
+-
+ /*!
+ \brief Abstract operation for GAP buffers.
+ Receives functor F as a template argument
+@@ -2264,7 +2343,6 @@
+ can be 0 or 1 (1 inverts the vector)
+ \param vect2 - operand 2 GAP encoded buffer.
+ \param vect2_mask - same as vect1_mask
+- \param f - operation functor.
+ \param dlen - destination length after the operation
+
+ \note Internal function.
+@@ -2278,8 +2356,7 @@
+ unsigned vect1_mask,
+ const T* BMRESTRICT vect2,
+ unsigned vect2_mask,
+- F& f,
+- unsigned& dlen)
++ unsigned& dlen) BMNOEXCEPT2
+ {
+ const T* cur1 = vect1;
+ const T* cur2 = vect2;
+@@ -2287,7 +2364,7 @@
+ T bitval1 = (T)((*cur1++ & 1) ^ vect1_mask);
+ T bitval2 = (T)((*cur2++ & 1) ^ vect2_mask);
+
+- T bitval = (T) f(bitval1, bitval2);
++ T bitval = (T) F::op(bitval1, bitval2);
+ T bitval_prev = bitval;
+
+ T* res = dest;
+@@ -2297,7 +2374,7 @@
+ T c1 = *cur1; T c2 = *cur2;
+ while (1)
+ {
+- bitval = (T) f(bitval1, bitval2);
++ bitval = (T) F::op(bitval1, bitval2);
+
+ // Check if GAP value changes and we need to
+ // start the next one
+@@ -2327,7 +2404,6 @@
+ }
+ ++cur2; c2 = *cur2;
+ }
+-
+ } // while
+
+ dlen = (unsigned)(res - dest);
+@@ -2334,12 +2410,12 @@
+ *dest = (T)((*dest & 7) + (dlen << 3));
+ }
+
++
+ /*!
+ \brief Abstract operation for GAP buffers (predicts legth)
+ Receives functor F as a template argument
+ \param vect1 - operand 1 GAP encoded buffer.
+ \param vect2 - operand 2 GAP encoded buffer.
+- \param f - operation functor.
+ \param dlen - destination length after the operation
+ \param limit - maximum target length limit,
+ returns false if limit is reached
+@@ -2354,9 +2430,8 @@
+ template<typename T, class F>
+ bool gap_buff_dry_op(const T* BMRESTRICT vect1,
+ const T* BMRESTRICT vect2,
+- F& f,
+ unsigned& dlen,
+- unsigned limit)
++ unsigned limit) BMNOEXCEPT2
+ {
+ const T* cur1 = vect1;
+ const T* cur2 = vect2;
+@@ -2364,7 +2439,7 @@
+ T bitval1 = (T)((*cur1++ & 1));
+ T bitval2 = (T)((*cur2++ & 1));
+
+- T bitval = (T) f(bitval1, bitval2);
++ T bitval = (T) F::op(bitval1, bitval2);
+ T bitval_prev = bitval;
+
+ unsigned len = 1;
+@@ -2372,7 +2447,7 @@
+ T c1 = *cur1; T c2 = *cur2;
+ while (1)
+ {
+- bitval = (T) f(bitval1, bitval2);
++ bitval = (T) F::op(bitval1, bitval2);
+
+ // Check if GAP value changes and we need to
+ // start the next one
+@@ -2418,7 +2493,6 @@
+ can be 0 or 1 (1 inverts the vector)
+ \param vect2 - operand 2 GAP encoded buffer.
+ \param vect2_mask - same as vect1_mask
+- \param f - operation functor.
+ \note Internal function.
+ \return non zero value if operation result returns any 1 bit
+
+@@ -2428,8 +2502,7 @@
+ unsigned gap_buff_any_op(const T* BMRESTRICT vect1,
+ unsigned vect1_mask,
+ const T* BMRESTRICT vect2,
+- unsigned vect2_mask,
+- F f)
++ unsigned vect2_mask) BMNOEXCEPT2
+ {
+ const T* cur1 = vect1;
+ const T* cur2 = vect2;
+@@ -2437,7 +2510,7 @@
+ unsigned bitval1 = (*cur1++ & 1) ^ vect1_mask;
+ unsigned bitval2 = (*cur2++ & 1) ^ vect2_mask;
+
+- unsigned bitval = f(bitval1, bitval2);
++ unsigned bitval = F::op(bitval1, bitval2);
+ if (bitval)
+ return bitval;
+ unsigned bitval_prev = bitval;
+@@ -2444,7 +2517,7 @@
+
+ while (1)
+ {
+- bitval = f(bitval1, bitval2);
++ bitval = F::op(bitval1, bitval2);
+ if (bitval)
+ return bitval;
+
+@@ -2468,10 +2541,8 @@
+ {
+ break;
+ }
+-
+ ++cur1;
+- bitval1 ^= 1;
+- bitval2 ^= 1;
++ bitval1 ^= 1; bitval2 ^= 1;
+ }
+ ++cur2;
+ }
+@@ -2488,13 +2559,12 @@
+ Receives functor F as a template argument
+ \param vect1 - operand 1 GAP encoded buffer.
+ \param vect2 - operand 2 GAP encoded buffer.
+- \param f - operation functor.
+ \note Internal function.
+
+ @ingroup gapfunc
+ */
+ template<typename T, class F>
+-unsigned gap_buff_count_op(const T* vect1, const T* vect2, F f)
++unsigned gap_buff_count_op(const T* vect1, const T* vect2) BMNOEXCEPT2
+ {
+ unsigned count;// = 0;
+ const T* cur1 = vect1;
+@@ -2502,18 +2572,15 @@
+
+ unsigned bitval1 = (*cur1++ & 1);
+ unsigned bitval2 = (*cur2++ & 1);
+- unsigned bitval = count = f(bitval1, bitval2);
++ unsigned bitval = count = F::op(bitval1, bitval2);
+ unsigned bitval_prev = bitval;
+
+- //if (bitval) ++count;
+-
+ T res, res_prev;
+ res = res_prev = 0;
+
+ while (1)
+ {
+- bitval = f(bitval1, bitval2);
+-
++ bitval = F::op(bitval1, bitval2);
+ // Check if GAP value changes and we need to
+ // start the next one.
+ if (bitval != bitval_prev)
+@@ -2530,8 +2597,7 @@
+ count += res - res_prev;
+ res_prev = res;
+ }
+- ++cur1;
+- bitval1 ^= 1;
++ ++cur1; bitval1 ^= 1;
+ }
+ else // >=
+ {
+@@ -2548,13 +2614,10 @@
+ else // equal
+ {
+ if (*cur2 == (bm::gap_max_bits - 1))
+- {
+ break;
+- }
+
+ ++cur1;
+- bitval1 ^= 1;
+- bitval2 ^= 1;
++ bitval1 ^= 1; bitval2 ^= 1;
+ }
+ ++cur2;
+ }
+@@ -2565,6 +2628,10 @@
+ }
+
+
++#ifdef __GNUG__
++#pragma GCC diagnostic push
++#pragma GCC diagnostic ignored "-Wconversion"
++#endif
+
+ /*!
+ \brief Sets or clears bit in the GAP buffer.
+@@ -2582,11 +2649,11 @@
+ unsigned gap_set_value(unsigned val,
+ T* BMRESTRICT buf,
+ unsigned pos,
+- unsigned* BMRESTRICT is_set)
++ unsigned* BMRESTRICT is_set) BMNOEXCEPT
+ {
+ BM_ASSERT(pos < bm::gap_max_bits);
+- unsigned curr = gap_bfind(buf, pos, is_set);
+
++ unsigned curr = bm::gap_bfind(buf, pos, is_set);
+ T end = (T)(*buf >> 3);
+ if (*is_set == val)
+ {
+@@ -2601,10 +2668,10 @@
+
+ // Special case, first bit GAP operation. There is no platform beside it.
+ // initial flag must be inverted.
+- if (pos == 0)
++ if (!pos)
+ {
+ *buf ^= 1;
+- if ( buf[1] ) // We need to insert a 1 bit platform here.
++ if (buf[1]) // We need to insert a 1 bit GAP here
+ {
+ ::memmove(&buf[2], &buf[1], (end - 1) * sizeof(gap_word_t));
+ buf[1] = 0;
+@@ -2612,52 +2679,125 @@
+ }
+ else // Only 1 bit in the GAP. We need to delete the first GAP.
+ {
+- pprev = buf + 1;
+- pcurr = pprev + 1;
+- do
+- {
+- *pprev++ = *pcurr++;
+- } while (pcurr < pend);
+- --end;
++ pprev = buf + 1; pcurr = pprev + 1;
++ goto copy_gaps;
+ }
+ }
+- else if (curr > 1 && ((unsigned)(*pprev))+1 == pos) // Left border bit
++ else
++ if (curr > 1 && ((unsigned)(*pprev))+1 == pos) // Left border bit
+ {
+ ++(*pprev);
+ if (*pprev == *pcurr) // Curr. GAP to be merged with prev.GAP.
+ {
+ --end;
+- if (pcurr != pend) // GAP merge: 2 GAPS to be deleted
++ if (pcurr != pend) // GAP merge: 2 GAPS to be deleted
+ {
++ ++pcurr;
++ copy_gaps:
+ --end;
+- ++pcurr;
+- do
+- {
+- *pprev++ = *pcurr++;
+- } while (pcurr < pend);
++ do { *pprev++ = *pcurr++; } while (pcurr < pend);
+ }
+ }
+ }
+- else if (*pcurr == pos) // Rightmost bit in the GAP. Border goes left.
++ else
++ if (*pcurr == pos) // Rightmost bit in the GAP. Border goes left.
+ {
+- --(*pcurr);
+- if (pcurr == pend)
++ --(*pcurr);
++ end += (pcurr == pend);
++ }
++ else // Worst case: split current GAP
++ {
++ if (*pcurr != bm::gap_max_bits-1) // last gap does not need memmove
++ ::memmove(pcurr+2, pcurr, (end - curr + 1)*(sizeof(T)));
++ end += 2;
++ pcurr[0] = (T)(pos-1);
++ pcurr[1] = (T)pos;
++ }
++
++ // Set correct length word and last border word
++ *buf = (T)((*buf & 7) + (end << 3));
++ buf[end] = bm::gap_max_bits-1;
++ return end;
++}
++
++/*!
++ \brief Sets or clears bit in the GAP buffer.
++
++ \param val - new bit value
++ \param buf - GAP buffer.
++ \param pos - Index of bit to set.
++
++ \return New GAP buffer length.
++
++ @ingroup gapfunc
++*/
++template<typename T>
++unsigned gap_set_value(unsigned val,
++ T* BMRESTRICT buf,
++ unsigned pos) BMNOEXCEPT
++{
++ BM_ASSERT(pos < bm::gap_max_bits);
++ unsigned is_set;
++ unsigned curr = bm::gap_bfind(buf, pos, &is_set);
++ T end = (T)(*buf >> 3);
++ if (is_set == val)
++ return end;
++
++ T* pcurr = buf + curr;
++ T* pprev = pcurr - 1;
++ T* pend = buf + end;
++
++ // Special case, first bit GAP operation. There is no platform beside it.
++ // initial flag must be inverted.
++ if (!pos)
++ {
++ *buf ^= 1;
++ if (buf[1]) // We need to insert a 1 bit GAP here
+ {
+- ++end;
++ ::memmove(&buf[2], &buf[1], (end - 1) * sizeof(gap_word_t));
++ buf[1] = 0;
++ ++end;
+ }
++ else // Only 1 bit in the GAP. We need to delete the first GAP.
++ {
++ pprev = buf + 1; pcurr = pprev + 1;
++ goto copy_gaps;
++ }
+ }
+- else // Worst case we need to split current block.
++ else
++ if (curr > 1 && ((unsigned)(*pprev))+1 == pos) // Left border bit
+ {
+- ::memmove(pcurr+2, pcurr,(end - curr + 1)*sizeof(T));
+- *pcurr++ = (T)(pos - 1);
+- *pcurr = (T)pos;
+- end = (T)(end + 2);
++ ++(*pprev);
++ if (*pprev == *pcurr) // Curr. GAP to be merged with prev.GAP.
++ {
++ --end;
++ if (pcurr != pend) // GAP merge: 2 GAPS to be deleted
++ {
++ ++pcurr;
++ copy_gaps:
++ --end;
++ do { *pprev++ = *pcurr++; } while (pcurr < pend);
++ }
++ }
+ }
++ else
++ if (*pcurr == pos) // Rightmost bit in the GAP. Border goes left.
++ {
++ --(*pcurr);
++ end += (pcurr == pend);
++ }
++ else // Worst case: split current GAP
++ {
++ if (*pcurr != bm::gap_max_bits-1) // last gap does not need memmove
++ ::memmove(pcurr+2, pcurr, (end - curr + 1)*(sizeof(T)));
++ end += 2;
++ pcurr[0] = (T)(pos-1);
++ pcurr[1] = (T)pos;
++ }
+
+- // Set correct length word.
++ // Set correct length word and last border word
+ *buf = (T)((*buf & 7) + (end << 3));
+-
+- buf[end] = bm::gap_max_bits - 1;
++ buf[end] = bm::gap_max_bits-1;
+ return end;
+ }
+
+@@ -2672,7 +2812,7 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-unsigned gap_add_value(T* buf, unsigned pos)
++unsigned gap_add_value(T* buf, unsigned pos) BMNOEXCEPT
+ {
+ BM_ASSERT(pos < bm::gap_max_bits);
+
+@@ -2684,7 +2824,7 @@
+
+ // Special case, first bit GAP operation. There is no platform beside it.
+ // initial flag must be inverted.
+- if (pos == 0)
++ if (!pos)
+ {
+ *buf ^= 1;
+ if ( buf[1] ) // We need to insert a 1 bit platform here.
+@@ -2695,13 +2835,9 @@
+ }
+ else // Only 1 bit in the GAP. We need to delete the first GAP.
+ {
+- pprev = buf + 1;
+- pcurr = pprev + 1;
+- do
+- {
+- *pprev++ = *pcurr++;
+- } while (pcurr < pend);
++ pprev = buf + 1; pcurr = pprev + 1;
+ --end;
++ do { *pprev++ = *pcurr++; } while (pcurr < pend);
+ }
+ }
+ else if (((unsigned)(*pprev))+1 == pos && (curr > 1) ) // Left border bit
+@@ -2710,40 +2846,32 @@
+ if (*pprev == *pcurr) // Curr. GAP to be merged with prev.GAP.
+ {
+ --end;
+- if (pcurr != pend) // GAP merge: 2 GAPS to be deleted
+- {
+- // TODO: should never get here...
+- --end;
+- ++pcurr;
+- do
+- {
+- *pprev++ = *pcurr++;
+- } while (pcurr < pend);
+- }
+- }
++ BM_ASSERT(pcurr == pend);
++ }
+ }
+ else if (*pcurr == pos) // Rightmost bit in the GAP. Border goes left.
+ {
+ --(*pcurr);
+- if (pcurr == pend)
+- {
+- ++end;
+- }
++ end += (pcurr == pend);
+ }
+ else // Worst case we need to split current block.
+ {
+- *pcurr++ = (T)(pos - 1);
+- *pcurr = (T)pos;
++ pcurr[0] = (T)(pos-1);
++ pcurr[1] = (T)pos;
+ end = (T)(end+2);
+ }
+
+ // Set correct length word.
+ *buf = (T)((*buf & 7) + (end << 3));
+-
+ buf[end] = bm::gap_max_bits - 1;
+ return end;
+ }
+
++#ifdef __GNUG__
++#pragma GCC diagnostic pop
++#endif
++
++
+ /*!
+ @brief Right shift GAP block by 1 bit
+ @param buf - block pointer
+@@ -2754,7 +2882,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-bool gap_shift_r1(T* buf, unsigned co_flag, unsigned* new_len)
++bool gap_shift_r1(T* BMRESTRICT buf,
++ unsigned co_flag, unsigned* BMRESTRICT new_len) BMNOEXCEPT
+ {
+ BM_ASSERT(new_len);
+ bool co;
+@@ -2802,7 +2931,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-bool gap_shift_l1(T* buf, unsigned co_flag, unsigned* new_len)
++bool gap_shift_l1(T* BMRESTRICT buf,
++ unsigned co_flag, unsigned* BMRESTRICT new_len) BMNOEXCEPT
+ {
+ BM_ASSERT(new_len);
+ unsigned is_set;
+@@ -2860,7 +2990,7 @@
+ */
+
+ template<typename T>
+-unsigned gap_set_array(T* buf, const T* arr, unsigned len)
++unsigned gap_set_array(T* buf, const T* arr, unsigned len) BMNOEXCEPT
+ {
+ *buf = (T)((*buf & 6u) + (1u << 3)); // gap header setup
+
+@@ -2921,8 +3051,7 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-unsigned bit_array_compute_gaps(const T* arr,
+- unsigned len)
++unsigned bit_array_compute_gaps(const T* arr, unsigned len) BMNOEXCEPT
+ {
+ unsigned gap_count = 1;
+ T prev = arr[0];
+@@ -2954,9 +3083,9 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-unsigned gap_block_find(const T* buf,
++unsigned gap_block_find(const T* BMRESTRICT buf,
+ unsigned nbit,
+- bm::id_t* prev)
++ bm::id_t* BMRESTRICT prev) BMNOEXCEPT
+ {
+ BM_ASSERT(nbit < bm::gap_max_bits);
+
+@@ -2968,19 +3097,20 @@
+ *prev = nbit;
+ return 1u;
+ }
+-
+ unsigned val = buf[gap_idx] + 1;
+ *prev = val;
+-
+ return (val != bm::gap_max_bits); // no bug here.
+ }
+
++//------------------------------------------------------------------------
++
++
+ /*!
+ \brief Set 1 bit in a block
+ @ingroup bitfunc
+ */
+ BMFORCEINLINE
+-void set_bit(unsigned* dest, unsigned bitpos)
++void set_bit(unsigned* dest, unsigned bitpos) BMNOEXCEPT
+ {
+ unsigned nbit = unsigned(bitpos & bm::set_block_mask);
+ unsigned nword = unsigned(nbit >> bm::set_word_shift);
+@@ -2993,7 +3123,7 @@
+ @ingroup bitfunc
+ */
+ BMFORCEINLINE
+-void clear_bit(unsigned* dest, unsigned bitpos)
++void clear_bit(unsigned* dest, unsigned bitpos) BMNOEXCEPT
+ {
+ unsigned nbit = unsigned(bitpos & bm::set_block_mask);
+ unsigned nword = unsigned(nbit >> bm::set_word_shift);
+@@ -3007,7 +3137,7 @@
+ @ingroup bitfunc
+ */
+ BMFORCEINLINE
+-unsigned test_bit(const unsigned* block, unsigned bitpos)
++unsigned test_bit(const unsigned* block, unsigned bitpos) BMNOEXCEPT
+ {
+ unsigned nbit = unsigned(bitpos & bm::set_block_mask);
+ unsigned nword = unsigned(nbit >> bm::set_word_shift);
+@@ -3025,7 +3155,7 @@
+ @ingroup bitfunc
+ */
+ inline
+-void or_bit_block(unsigned* dest, unsigned bitpos, unsigned bitcount)
++void or_bit_block(unsigned* dest, unsigned bitpos, unsigned bitcount) BMNOEXCEPT
+ {
+ const unsigned maskFF = ~0u;
+
+@@ -3072,7 +3202,7 @@
+ @ingroup bitfunc
+ */
+ inline
+-void sub_bit_block(unsigned* dest, unsigned bitpos, unsigned bitcount)
++void sub_bit_block(unsigned* dest, unsigned bitpos, unsigned bitcount) BMNOEXCEPT
+ {
+ const unsigned maskFF = ~0u;
+
+@@ -3121,7 +3251,7 @@
+ */
+ inline void xor_bit_block(unsigned* dest,
+ unsigned bitpos,
+- unsigned bitcount)
++ unsigned bitcount) BMNOEXCEPT
+ {
+ unsigned nbit = unsigned(bitpos & bm::set_block_mask);
+ unsigned nword = unsigned(nbit >> bm::set_word_shift);
+@@ -3175,7 +3305,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-void gap_sub_to_bitset(unsigned* dest, const T* pcurr)
++void gap_sub_to_bitset(unsigned* BMRESTRICT dest,
++ const T* BMRESTRICT pcurr) BMNOEXCEPT
+ {
+ BM_ASSERT(dest && pcurr);
+
+@@ -3203,7 +3334,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-void gap_sub_to_bitset(unsigned* dest, const T* pcurr, bm::id64_t digest0)
++void gap_sub_to_bitset(unsigned* BMRESTRICT dest,
++ const T* BMRESTRICT pcurr, bm::id64_t digest0) BMNOEXCEPT
+ {
+ BM_ASSERT(dest && pcurr);
+
+@@ -3261,7 +3393,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-void gap_xor_to_bitset(unsigned* dest, const T* pcurr)
++void gap_xor_to_bitset(unsigned* BMRESTRICT dest,
++ const T* BMRESTRICT pcurr) BMNOEXCEPT
+ {
+ BM_ASSERT(dest && pcurr);
+
+@@ -3288,7 +3421,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-void gap_add_to_bitset(unsigned* dest, const T* pcurr, unsigned len)
++void gap_add_to_bitset(unsigned* BMRESTRICT dest,
++ const T* BMRESTRICT pcurr, unsigned len) BMNOEXCEPT
+ {
+ BM_ASSERT(dest && pcurr);
+
+@@ -3321,7 +3455,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-void gap_add_to_bitset(unsigned* dest, const T* pcurr)
++void gap_add_to_bitset(unsigned* BMRESTRICT dest,
++ const T* BMRESTRICT pcurr) BMNOEXCEPT
+ {
+ unsigned len = (*pcurr >> 3);
+ gap_add_to_bitset(dest, pcurr, len);
+@@ -3336,7 +3471,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-void gap_and_to_bitset(unsigned* dest, const T* pcurr)
++void gap_and_to_bitset(unsigned* BMRESTRICT dest,
++ const T* BMRESTRICT pcurr) BMNOEXCEPT
+ {
+ BM_ASSERT(dest && pcurr);
+
+@@ -3370,7 +3506,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-void gap_and_to_bitset(unsigned* dest, const T* pcurr, bm::id64_t digest0)
++void gap_and_to_bitset(unsigned* BMRESTRICT dest,
++ const T* BMRESTRICT pcurr, bm::id64_t digest0) BMNOEXCEPT
+ {
+ BM_ASSERT(dest && pcurr);
+ if (!digest0)
+@@ -3431,7 +3568,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-bm::id_t gap_bitset_and_count(const unsigned* block, const T* pcurr)
++bm::id_t gap_bitset_and_count(const unsigned* BMRESTRICT block,
++ const T* BMRESTRICT pcurr) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+ const T* pend = pcurr + (*pcurr >> 3);
+@@ -3458,7 +3596,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-bm::id_t gap_bitset_and_any(const unsigned* block, const T* pcurr)
++bm::id_t gap_bitset_and_any(const unsigned* BMRESTRICT block,
++ const T* BMRESTRICT pcurr) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+
+@@ -3487,7 +3626,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-bm::id_t gap_bitset_sub_count(const unsigned* block, const T* buf)
++bm::id_t gap_bitset_sub_count(const unsigned* BMRESTRICT block,
++ const T* BMRESTRICT buf) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+
+@@ -3521,7 +3661,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-bm::id_t gap_bitset_sub_any(const unsigned* block, const T* buf)
++bm::id_t gap_bitset_sub_any(const unsigned* BMRESTRICT block,
++ const T* BMRESTRICT buf) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+
+@@ -3558,7 +3699,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-bm::id_t gap_bitset_xor_count(const unsigned* block, const T* buf)
++bm::id_t gap_bitset_xor_count(const unsigned* BMRESTRICT block,
++ const T* BMRESTRICT buf) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+
+@@ -3595,7 +3737,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-bm::id_t gap_bitset_xor_any(const unsigned* block, const T* buf)
++bm::id_t gap_bitset_xor_any(const unsigned* BMRESTRICT block,
++ const T* BMRESTRICT buf) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+
+@@ -3632,10 +3775,10 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-bm::id_t gap_bitset_or_count(const unsigned* block, const T* buf)
++bm::id_t gap_bitset_or_count(const unsigned* BMRESTRICT block,
++ const T* BMRESTRICT buf) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+-
+ const T* pcurr = buf;
+ const T* pend = pcurr + (*pcurr >> 3);
+ ++pcurr;
+@@ -3664,7 +3807,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-bm::id_t gap_bitset_or_any(const unsigned* block, const T* buf)
++bm::id_t gap_bitset_or_any(const unsigned* BMRESTRICT block,
++ const T* BMRESTRICT buf) BMNOEXCEPT
+ {
+ bool b = !bm::gap_is_all_zero(buf) ||
+ !bm::bit_is_all_zero(block);
+@@ -3682,7 +3826,7 @@
+ @ingroup bitfunc
+ */
+ inline
+-void bit_block_set(bm::word_t* BMRESTRICT dst, bm::word_t value)
++void bit_block_set(bm::word_t* BMRESTRICT dst, bm::word_t value) BMNOEXCEPT
+ {
+ #ifdef BMVECTOPT
+ VECT_SET_BLOCK(dst, value);
+@@ -3700,7 +3844,8 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-void gap_convert_to_bitset(unsigned* dest, const T* buf)
++void gap_convert_to_bitset(unsigned* BMRESTRICT dest,
++ const T* BMRESTRICT buf) BMNOEXCEPT
+ {
+ bm::bit_block_set(dest, 0);
+ bm::gap_add_to_bitset(dest, buf);
+@@ -3721,13 +3866,12 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-unsigned* gap_convert_to_bitset_smart(unsigned* dest,
+- const T* buf,
+- id_t set_max)
++unsigned* gap_convert_to_bitset_smart(unsigned* BMRESTRICT dest,
++ const T* BMRESTRICT buf,
++ id_t set_max) BMNOEXCEPT
+ {
+ if (buf[1] == set_max - 1)
+ return (buf[0] & 1) ? FULL_BLOCK_REAL_ADDR : 0;
+-
+ bm::gap_convert_to_bitset(dest, buf);
+ return dest;
+ }
+@@ -3742,7 +3886,8 @@
+ @ingroup gapfunc
+ @internal
+ */
+-template<typename T> unsigned gap_control_sum(const T* buf)
++template<typename T>
++unsigned gap_control_sum(const T* buf) BMNOEXCEPT
+ {
+ unsigned end = *buf >> 3;
+
+@@ -3755,7 +3900,6 @@
+ ++pcurr;
+ }
+ ++pcurr; // now we are in GAP "1" again
+-
+ while (pcurr <= pend)
+ {
+ BM_ASSERT(*pcurr > *(pcurr-1));
+@@ -3773,9 +3917,8 @@
+
+ @ingroup gapfunc
+ */
+-template<class T> void gap_set_all(T* buf,
+- unsigned set_max,
+- unsigned value)
++template<class T>
++void gap_set_all(T* buf, unsigned set_max, unsigned value) BMNOEXCEPT
+ {
+ BM_ASSERT(value == 0 || value == 1);
+ *buf = (T)((*buf & 6u) + (1u << 3) + value);
+@@ -3796,8 +3939,7 @@
+ void gap_init_range_block(T* buf,
+ T from,
+ T to,
+- T value)
+- //unsigned set_max)
++ T value) BMNOEXCEPT
+ {
+ BM_ASSERT(value == 0 || value == 1);
+ const unsigned set_max = bm::bits_in_block;
+@@ -3844,7 +3986,7 @@
+
+ @ingroup gapfunc
+ */
+-template<typename T> void gap_invert(T* buf)
++template<typename T> void gap_invert(T* buf) BMNOEXCEPT
+ {
+ *buf ^= 1;
+ }
+@@ -3863,7 +4005,7 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-void set_gap_level(T* buf, int level)
++void set_gap_level(T* buf, int level) BMNOEXCEPT
+ {
+ BM_ASSERT(level >= 0);
+ BM_ASSERT(unsigned(level) < bm::gap_levels);
+@@ -3885,7 +4027,7 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-inline int gap_calc_level(unsigned len, const T* glevel_len)
++int gap_calc_level(unsigned len, const T* glevel_len) BMNOEXCEPT
+ {
+ if (len <= unsigned(glevel_len[0]-4)) return 0;
+ if (len <= unsigned(glevel_len[1]-4)) return 1;
+@@ -3906,10 +4048,11 @@
+ @ingroup gapfunc
+ */
+ template<typename T>
+-inline unsigned gap_free_elements(const T* buf, const T* glevel_len)
++inline unsigned gap_free_elements(const T* BMRESTRICT buf,
++ const T* BMRESTRICT glevel_len) BMNOEXCEPT
+ {
+- unsigned len = gap_length(buf);
+- unsigned capacity = gap_capacity(buf, glevel_len);
++ unsigned len = bm::gap_length(buf);
++ unsigned capacity = bm::gap_capacity(buf, glevel_len);
+ return capacity - len;
+ }
+
+@@ -3923,7 +4066,7 @@
+ @ingroup bitfunc
+ */
+ template<typename T>
+-int bitcmp(const T* buf1, const T* buf2, unsigned len)
++int bitcmp(const T* buf1, const T* buf2, unsigned len) BMNOEXCEPT
+ {
+ BM_ASSERT(len);
+ const T* pend1 = buf1 + len;
+@@ -3948,8 +4091,9 @@
+ @ingroup bitfunc
+ */
+ inline
+-bool bit_find_first_diff(const bm::word_t* blk1, const bm::word_t* blk2,
+- unsigned* pos)
++bool bit_find_first_diff(const bm::word_t* BMRESTRICT blk1,
++ const bm::word_t* BMRESTRICT blk2,
++ unsigned* BMRESTRICT pos) BMNOEXCEPT
+ {
+ BM_ASSERT(blk1 && blk2 && pos);
+ #ifdef VECT_BIT_FIND_DIFF
+@@ -3969,7 +4113,7 @@
+ if (diff)
+ {
+ unsigned idx = bm::count_trailing_zeros_u64(diff);
+- *pos = unsigned(idx + (i * 8u * sizeof(bm::wordop_t)));
++ *pos = unsigned(idx + (i * 8u * unsigned(sizeof(bm::wordop_t))));
+ return true;
+ }
+ } // for
+@@ -3997,7 +4141,7 @@
+ \brief Converts bit block to GAP.
+ \param dest - Destinatio GAP buffer.
+ \param block - Source bitblock buffer.
+- \param dest_len - length of the dest. buffer.
++ \param dest_len - length of the destination buffer.
+ \return New length of GAP block or 0 if conversion failed
+ (insufficicent space).
+
+@@ -4006,7 +4150,7 @@
+ inline
+ unsigned bit_block_to_gap(gap_word_t* BMRESTRICT dest,
+ const unsigned* BMRESTRICT block,
+- unsigned dest_len)
++ unsigned dest_len) BMNOEXCEPT
+ {
+ const unsigned* BMRESTRICT block_end = block + bm::set_block_size;
+ gap_word_t* BMRESTRICT pcurr = dest;
+@@ -4083,10 +4227,15 @@
+ }
+ #endif
+
++/**
++ Convert bit block to GAP representation
++ @internal
++ @ingroup bitfunc
++*/
+ inline
+ unsigned bit_to_gap(gap_word_t* BMRESTRICT dest,
+ const unsigned* BMRESTRICT block,
+- unsigned dest_len)
++ unsigned dest_len) BMNOEXCEPT
+ {
+ #if defined(VECT_BIT_TO_GAP)
+ return VECT_BIT_TO_GAP(dest, block, dest_len);
+@@ -4159,10 +4308,10 @@
+ D gap_convert_to_arr(D* BMRESTRICT dest,
+ const T* BMRESTRICT buf,
+ unsigned dest_len,
+- bool invert = false)
++ bool invert = false) BMNOEXCEPT
+ {
+- BMREGISTER const T* BMRESTRICT pcurr = buf;
+- BMREGISTER const T* pend = pcurr + (*pcurr >> 3);
++ const T* BMRESTRICT pcurr = buf;
++ const T* pend = pcurr + (*pcurr >> 3);
+
+ D* BMRESTRICT dest_curr = dest;
+ ++pcurr;
+@@ -4215,7 +4364,7 @@
+ @ingroup bitfunc
+ */
+ inline
+-bm::id_t bit_block_count(const bm::word_t* block)
++bm::id_t bit_block_count(const bm::word_t* block) BMNOEXCEPT
+ {
+ const bm::word_t* block_end = block + bm::set_block_size;
+ bm::id_t count = 0;
+@@ -4278,8 +4427,12 @@
+ @ingroup bitfunc
+ */
+ inline
+-bm::id_t bit_block_count(const bm::word_t* const block, bm::id64_t digest)
++bm::id_t bit_block_count(const bm::word_t* const block,
++ bm::id64_t digest) BMNOEXCEPT
+ {
++#ifdef VECT_BIT_COUNT_DIGEST
++ return VECT_BIT_COUNT_DIGEST(block, digest);
++#else
+ bm::id_t count = 0;
+ bm::id64_t d = digest;
+ while (d)
+@@ -4304,6 +4457,7 @@
+ d = bm::bmi_bslr_u64(d); // d &= d - 1;
+ } // while
+ return count;
++#endif
+ }
+
+
+@@ -4318,7 +4472,7 @@
+ */
+ inline
+ bm::id_t bit_block_calc_count(const bm::word_t* block,
+- const bm::word_t* block_end)
++ const bm::word_t* block_end) BMNOEXCEPT
+ {
+ bm::id_t count = 0;
+ bm::word_t acc = *block++;
+@@ -4352,7 +4506,7 @@
+ @ingroup bitfunc
+ */
+ inline
+-bm::id_t bit_count_change(bm::word_t w)
++bm::id_t bit_count_change(bm::word_t w) BMNOEXCEPT
+ {
+ unsigned count = 1;
+ w ^= (w >> 1);
+@@ -4368,7 +4522,7 @@
+ @internal
+ */
+ inline
+-unsigned bit_block_change32(const bm::word_t* block, unsigned size)
++unsigned bit_block_change32(const bm::word_t* block, unsigned size) BMNOEXCEPT
+ {
+ unsigned gap_count = 1;
+
+@@ -4416,7 +4570,8 @@
+ @internal
+ */
+ inline
+-void bit_block_change_bc(const bm::word_t* block, unsigned* gc, unsigned* bc)
++void bit_block_change_bc(const bm::word_t* BMRESTRICT block,
++ unsigned* BMRESTRICT gc, unsigned* BMRESTRICT bc) BMNOEXCEPT
+ {
+ BM_ASSERT(gc);
+ BM_ASSERT(bc);
+@@ -4441,7 +4596,7 @@
+ @ingroup bitfunc
+ */
+ inline
+-unsigned bit_block_calc_change(const bm::word_t* block)
++unsigned bit_block_calc_change(const bm::word_t* block) BMNOEXCEPT
+ {
+ #if defined(VECT_BLOCK_CHANGE)
+ return VECT_BLOCK_CHANGE(block, bm::set_block_size);
+@@ -4450,8 +4605,80 @@
+ #endif
+ }
+
++/*!
++ Check if all bits are 1 in [left, right] range
++ @ingroup bitfunc
++*/
++inline
++bool bit_block_is_all_one_range(const bm::word_t* const BMRESTRICT block,
++ bm::word_t left,
++ bm::word_t right) BMNOEXCEPT
++{
++ BM_ASSERT(left <= right);
++ BM_ASSERT(right <= bm::gap_max_bits-1);
+
++ unsigned nword, nbit, bitcount, temp;
++ nbit = left & bm::set_word_mask;
++ const bm::word_t* word =
++ block + (nword = unsigned(left >> bm::set_word_shift));
++ if (left == right) // special case (only 1 bit to check)
++ return (*word >> nbit) & 1u;
+
++ if (nbit) // starting position is not aligned
++ {
++ unsigned right_margin = nbit + right - left;
++ if (right_margin < 32)
++ {
++ unsigned mask =
++ block_set_table<true>::_right[nbit] &
++ block_set_table<true>::_left[right_margin];
++ return mask == (*word & mask);
++ }
++ temp = *word & block_set_table<true>::_right[nbit];
++ if (temp != block_set_table<true>::_right[nbit])
++ return false;
++ bitcount = (right - left + 1u) - (32 - nbit);
++ ++word;
++ }
++ else
++ {
++ bitcount = right - left + 1u;
++ }
++
++ // now when we are word aligned, we can scan the bit-stream
++ const bm::id64_t maskFF64 = ~0ull;
++ const bm::word_t maskFF = ~0u;
++ // loop unrolled to evaluate 4 words at a time
++ // SIMD showed no advantage, unless evaluate sub-wave intervals
++ //
++ for ( ;bitcount >= 128; bitcount-=128, word+=4)
++ {
++ bm::id64_t w64_0 = bm::id64_t(word[0]) + (bm::id64_t(word[1]) << 32);
++ bm::id64_t w64_1 = bm::id64_t(word[2]) + (bm::id64_t(word[3]) << 32);
++ if ((w64_0 ^ maskFF64) | (w64_1 ^ maskFF64))
++ return false;
++ } // for
++
++ for ( ;bitcount >= 32; bitcount-=32, ++word)
++ {
++ if (*word != maskFF)
++ return false;
++ } // for
++ BM_ASSERT(bitcount < 32);
++
++ if (bitcount) // we have a tail to count
++ {
++ temp = *word & block_set_table<true>::_left[bitcount-1];
++ if (temp != block_set_table<true>::_left[bitcount-1])
++ return false;
++ }
++
++ return true;
++}
++
++
++
++
+ /*!
+ Function calculates number of 1 bits in the given array of words in
+ the range between left anf right bits (borders included)
+@@ -4462,7 +4689,7 @@
+ inline
+ bm::id_t bit_block_calc_count_range(const bm::word_t* block,
+ bm::word_t left,
+- bm::word_t right)
++ bm::word_t right) BMNOEXCEPT
+ {
+ BM_ASSERT(left <= right);
+ BM_ASSERT(right <= bm::gap_max_bits-1);
+@@ -4530,7 +4757,7 @@
+ */
+ inline
+ bm::id_t bit_block_calc_count_to(const bm::word_t* block,
+- bm::word_t right)
++ bm::word_t right) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+ if (!right) // special case, first bit check
+@@ -4586,7 +4813,7 @@
+ @ingroup bitfunc
+ */
+ inline
+-void bit_block_rotate_left_1(bm::word_t* block)
++void bit_block_rotate_left_1(bm::word_t* block) BMNOEXCEPT
+ {
+ bm::word_t co_flag = (block[0] >> 31) & 1; // carry over bit
+ for (unsigned i = 0; i < bm::set_block_size-1; ++i)
+@@ -4602,7 +4829,7 @@
+ @ingroup bitfunc
+ */
+ inline
+-void bit_block_rotate_left_1_unr(bm::word_t* block)
++void bit_block_rotate_left_1_unr(bm::word_t* block) BMNOEXCEPT
+ {
+ bm::word_t co_flag = (block[0] >> 31) & 1; // carry over bit
+ const unsigned unroll_factor = 4;
+@@ -4638,7 +4865,8 @@
+ @ingroup bitfunc
+ */
+ inline
+-bm::word_t bit_block_insert(bm::word_t* block, unsigned bitpos, bool value)
++bm::word_t bit_block_insert(bm::word_t* BMRESTRICT block,
++ unsigned bitpos, bool value) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+ BM_ASSERT(bitpos < 65536);
+@@ -4686,8 +4914,9 @@
+ @ingroup bitfunc
+ */
+ inline
+-bool bit_block_shift_r1(bm::word_t* block,
+- bm::word_t* empty_acc, bm::word_t co_flag)
++bool bit_block_shift_r1(bm::word_t* BMRESTRICT block,
++ bm::word_t* BMRESTRICT empty_acc,
++ bm::word_t co_flag) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+ BM_ASSERT(empty_acc);
+@@ -4715,8 +4944,9 @@
+ @ingroup bitfunc
+ */
+ inline
+-bool bit_block_shift_r1_unr(bm::word_t* block,
+- bm::word_t* empty_acc, bm::word_t co_flag)
++bool bit_block_shift_r1_unr(bm::word_t* BMRESTRICT block,
++ bm::word_t* BMRESTRICT empty_acc,
++ bm::word_t co_flag) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+ BM_ASSERT(empty_acc);
+@@ -4740,7 +4970,7 @@
+ */
+ inline
+ bool bit_block_shift_l1(bm::word_t* block,
+- bm::word_t* empty_acc, bm::word_t co_flag)
++ bm::word_t* empty_acc, bm::word_t co_flag) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+ BM_ASSERT(empty_acc);
+@@ -4770,7 +5000,8 @@
+ */
+ inline
+ bool bit_block_shift_l1_unr(bm::word_t* block,
+- bm::word_t* empty_acc, bm::word_t co_flag)
++ bm::word_t* empty_acc,
++ bm::word_t co_flag) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+ BM_ASSERT(empty_acc);
+@@ -4791,7 +5022,9 @@
+ @ingroup bitfunc
+ */
+ inline
+-void bit_block_erase(bm::word_t* block, unsigned bitpos, bool carry_over)
++void bit_block_erase(bm::word_t* block,
++ unsigned bitpos,
++ bool carry_over) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+ BM_ASSERT(bitpos < 65536);
+@@ -4799,7 +5032,7 @@
+ if (!bitpos)
+ {
+ bm::word_t acc;
+- bit_block_shift_l1_unr(block, &acc, carry_over);
++ bm::bit_block_shift_l1_unr(block, &acc, carry_over);
+ return;
+ }
+
+@@ -4848,7 +5081,7 @@
+ bool bit_block_shift_r1_and(bm::word_t* BMRESTRICT block,
+ bm::word_t co_flag,
+ const bm::word_t* BMRESTRICT mask_block,
+- bm::id64_t* BMRESTRICT digest)
++ bm::id64_t* BMRESTRICT digest) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+ BM_ASSERT(mask_block);
+@@ -4896,7 +5129,7 @@
+
+ block[d_base] = co_flag & mask_block[d_base];
+ if (block[d_base])
+- d |= dmask; // update d
++ d |= dmask; // update digest
+ co_flag = 0;
+ }
+ }
+@@ -4920,7 +5153,7 @@
+ bool bit_block_shift_r1_and_unr(bm::word_t* BMRESTRICT block,
+ bm::word_t co_flag,
+ const bm::word_t* BMRESTRICT mask_block,
+- bm::id64_t* BMRESTRICT digest)
++ bm::id64_t* BMRESTRICT digest) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+ BM_ASSERT(mask_block);
+@@ -4942,9 +5175,9 @@
+ @ingroup bitfunc
+ */
+ inline
+-bm::id_t bit_block_any_range(const bm::word_t* block,
++bm::id_t bit_block_any_range(const bm::word_t* const BMRESTRICT block,
+ bm::word_t left,
+- bm::word_t right)
++ bm::word_t right) BMNOEXCEPT
+ {
+ BM_ASSERT(left <= right);
+
+@@ -4969,8 +5202,7 @@
+ unsigned mask =
+ block_set_table<true>::_right[nbit] &
+ block_set_table<true>::_left[right_margin];
+- acc = *word & mask;
+- return acc;
++ return *word & mask;
+ }
+ else
+ {
+@@ -4982,22 +5214,26 @@
+ ++word;
+ }
+
+- // now when we are word aligned, we can check bits the usual way
+- for ( ;bitcount >= 32; bitcount -= 32)
++ // loop unrolled to evaluate 4 words at a time
++ // SIMD showed no advantage, unless evaluate sub-wave intervals
++ //
++ for ( ;bitcount >= 128; bitcount-=128, word+=4)
+ {
+- acc = *word++;
+- if (acc)
++ acc = word[0] | word[1] | word[2] | word[3];
++ if (acc)
+ return acc;
+- }
++ } // for
+
+- if (bitcount) // we have a tail to count
++ acc = 0;
++ for ( ;bitcount >= 32; bitcount -= 32)
+ {
+- acc = (*word) & block_set_table<true>::_left[bitcount-1];
+- if (acc)
+- return acc;
+- }
++ acc |= *word++;
++ } // for
+
+- return 0;
++ if (bitcount) // we have a tail to count
++ acc |= (*word) & block_set_table<true>::_left[bitcount-1];
++
++ return acc;
+ }
+
+ // ----------------------------------------------------------------------
+@@ -5005,7 +5241,8 @@
+ /*! Function inverts block of bits
+ @ingroup bitfunc
+ */
+-template<typename T> void bit_invert(T* start)
++template<typename T>
++void bit_invert(T* start) BMNOEXCEPT
+ {
+ BM_ASSERT(IS_VALID_ADDR((bm::word_t*)start));
+ #ifdef BMVECTOPT
+@@ -5029,7 +5266,7 @@
+ @ingroup bitfunc
+ */
+ inline
+-bool is_bits_one(const bm::wordop_t* start)
++bool is_bits_one(const bm::wordop_t* start) BMNOEXCEPT
+ {
+ #if defined(BMSSE42OPT) || defined(BMAVX2OPT)
+ return VECT_IS_ONE_BLOCK(start);
+@@ -5050,35 +5287,311 @@
+
+ // ----------------------------------------------------------------------
+
+-// GAP blocks manipulation functions:
++/*! @brief Returns "true" if all bits are 1 in the block [left, right]
++ Function check for block varieties
++ @internal
++*/
++inline
++bool block_is_all_one_range(const bm::word_t* const BMRESTRICT block,
++ unsigned left, unsigned right) BMNOEXCEPT
++{
++ BM_ASSERT(left <= right);
++ BM_ASSERT(right < bm::gap_max_bits);
++ if (block)
++ {
++ if (BM_IS_GAP(block))
++ return bm::gap_is_all_one_range(BMGAP_PTR(block), left, right);
++ if (block == FULL_BLOCK_FAKE_ADDR)
++ return true;
++ return bm::bit_block_is_all_one_range(block, left, right);
++ }
++ return false;
++}
+
+-/*! \brief GAP and functor */
+-BMFORCEINLINE unsigned and_op(unsigned v1, unsigned v2)
++/*! @brief Returns "true" if all bits are 1 in the block [left, right]
++ and border bits are 0
++ @internal
++*/
++inline
++bool block_is_interval(const bm::word_t* const BMRESTRICT block,
++ unsigned left, unsigned right) BMNOEXCEPT
+ {
+- return v1 & v2;
++ BM_ASSERT(left <= right);
++ BM_ASSERT(right < bm::gap_max_bits-1);
++
++ if (block)
++ {
++ bool is_left, is_right, all_one;
++ if (BM_IS_GAP(block))
++ {
++ const bm::gap_word_t* gap = BMGAP_PTR(block);
++ all_one = bm::gap_is_interval(gap, left, right);
++ return all_one;
++ }
++ else // bit-block
++ {
++ if (block == FULL_BLOCK_FAKE_ADDR)
++ return false;
++ unsigned nword = ((left-1) >> bm::set_word_shift);
++ is_left = block[nword] & (1u << ((left-1) & bm::set_word_mask));
++ if (is_left == false)
++ {
++ nword = ((right + 1) >> bm::set_word_shift);
++ is_right = block[nword] & (1u << ((right + 1) & bm::set_word_mask));
++ if (is_right == false)
++ {
++ all_one = bm::bit_block_is_all_one_range(block, left, right);
++ return all_one;
++ }
++ }
++ }
++ }
++
++ return false;
+ }
+
++// ----------------------------------------------------------------------
+
+-/*! \brief GAP xor functor */
+-BMFORCEINLINE unsigned xor_op(unsigned v1, unsigned v2)
++/**
++ \brief Searches for the last 1 bit in the 111 interval of a BIT block
++ \param block - BIT buffer
++ \param nbit - bit index to start checking from
++ \param pos - [out] found value
++
++ \return false if not found
++ @ingroup bitfunc
++*/
++inline
++bool bit_block_find_interval_end(const bm::word_t* BMRESTRICT block,
++ unsigned nbit, unsigned* BMRESTRICT pos) BMNOEXCEPT
+ {
+- return v1 ^ v2;
++ BM_ASSERT(block);
++ BM_ASSERT(pos);
++
++ unsigned nword = unsigned(nbit >> bm::set_word_shift);
++ unsigned bit_pos = (nbit & bm::set_word_mask);
++ bm::word_t w = block[nword];
++ w &= (1u << bit_pos);
++ if (!w)
++ return false;
++
++ if (nbit == bm::gap_max_bits-1)
++ {
++ *pos = bm::gap_max_bits-1;
++ return true;
++ }
++ *pos = nbit;
++
++ ++nbit;
++ nword = unsigned(nbit >> bm::set_word_shift);
++ bit_pos = (nbit & bm::set_word_mask);
++
++ w = (~block[nword]) >> bit_pos;
++ w <<= bit_pos; // clear the trailing bits
++ if (w)
++ {
++ bit_pos = bm::bit_scan_forward32(w); // trailing zeros
++ *pos = unsigned(bit_pos + (nword * 8u * unsigned(sizeof(bm::word_t)))-1);
++ return true;
++ }
++
++ for (++nword; nword < bm::set_block_size; ++nword)
++ {
++ w = ~block[nword];
++ if (w)
++ {
++ bit_pos = bm::bit_scan_forward32(w); // trailing zeros
++ *pos = unsigned(bit_pos + (nword * 8u * unsigned(sizeof(bm::word_t)))-1);
++ return true;
++ }
++ } // for nword
++
++ // 0 not found, all block is 1s...
++ *pos = bm::gap_max_bits-1;
++ return true;
+ }
+
+
+-/*! \brief GAP or functor */
+-BMFORCEINLINE unsigned or_op(unsigned v1, unsigned v2)
++/*! @brief Find end of the current 111 interval
++ @return search result code 0 - not found, 1 found, 2 - found at the end
++ @internal
++*/
++inline
++unsigned block_find_interval_end(const bm::word_t* BMRESTRICT block,
++ unsigned nbit_from,
++ unsigned* BMRESTRICT found_nbit) BMNOEXCEPT
+ {
+- return v1 | v2;
++ BM_ASSERT(block && found_nbit);
++ BM_ASSERT(nbit_from < bm::gap_max_bits);
++
++ bool b;
++ if (BM_IS_GAP(block))
++ {
++ const bm::gap_word_t* gap = BMGAP_PTR(block);
++ b = bm::gap_find_interval_end(gap, nbit_from, found_nbit);
++ if (b && *found_nbit == bm::gap_max_bits-1)
++ return 2; // end of block, keep searching
++ }
++ else // bit-block
++ {
++ if (IS_FULL_BLOCK(block))
++ {
++ *found_nbit = bm::gap_max_bits-1;
++ return 2;
++ }
++ b = bm::bit_block_find_interval_end(block, nbit_from, found_nbit);
++ if (b && *found_nbit == bm::gap_max_bits-1)
++ return 2; // end of block, keep searching
++ }
++ return b;
+ }
+
+-/*! \brief GAP or functor */
+-BMFORCEINLINE unsigned sub_op(unsigned v1, unsigned v2)
++// ----------------------------------------------------------------------
++
++/**
++ \brief Searches for the first 1 bit in the 111 interval of a BIT block
++ \param block - BIT buffer
++ \param nbit - bit index to start checking from
++ \param pos - [out] found value
++
++ \return false if not found
++ @ingroup bitfunc
++*/
++inline
++bool bit_block_find_interval_start(const bm::word_t* BMRESTRICT block,
++ unsigned nbit, unsigned* BMRESTRICT pos) BMNOEXCEPT
+ {
+- return v1 & ~v2;
++ BM_ASSERT(block);
++ BM_ASSERT(pos);
++
++ unsigned nword = unsigned(nbit >> bm::set_word_shift);
++ unsigned bit_pos = (nbit & bm::set_word_mask);
++ bm::word_t w = block[nword];
++ w &= (1u << bit_pos);
++ if (!w)
++ return false;
++
++ if (nbit == 0)
++ {
++ *pos = 0;
++ return true;
++ }
++ *pos = nbit;
++
++ --nbit;
++ nword = unsigned(nbit >> bm::set_word_shift);
++ bit_pos = (nbit & bm::set_word_mask);
++
++ w = (~block[nword]) & block_set_table<true>::_left[bit_pos];
++ if (w)
++ {
++ bit_pos = bm::bit_scan_reverse32(w);
++ *pos = unsigned(bit_pos + (nword * 8u * unsigned(sizeof(bm::word_t)))+1);
++ return true;
++ }
++
++ if (nword)
++ {
++ for (--nword; true; --nword)
++ {
++ w = ~block[nword];
++ if (w)
++ {
++ bit_pos = bm::bit_scan_reverse32(w); // trailing zeros
++ *pos = unsigned(bit_pos + (nword * 8u * unsigned(sizeof(bm::word_t)))+1);
++ return true;
++ }
++ if (!nword)
++ break;
++ } // for nword
++ }
++
++ // 0 not found, all block is 1s...
++ *pos = 0;
++ return true;
+ }
+
+
++/*! @brief Find start of the current 111 interval
++ @return search result code 0 - not found, 1 found, 2 - found at the start
++ @internal
++*/
++inline
++unsigned block_find_interval_start(const bm::word_t* BMRESTRICT block,
++ unsigned nbit_from,
++ unsigned* BMRESTRICT found_nbit) BMNOEXCEPT
++{
++ BM_ASSERT(block && found_nbit);
++ BM_ASSERT(nbit_from < bm::gap_max_bits);
++ bool b;
++ if (BM_IS_GAP(block))
++ {
++ const bm::gap_word_t* gap = BMGAP_PTR(block);
++ b = bm::gap_find_interval_start(gap, nbit_from, found_nbit);
++ if (b && *found_nbit == 0)
++ return 2; // start of block, keep searching
++ }
++ else // bit-block
++ {
++ if (IS_FULL_BLOCK(block))
++ {
++ *found_nbit = 0;
++ return 2;
++ }
++ b = bm::bit_block_find_interval_start(block, nbit_from, found_nbit);
++ if (b && *found_nbit == 0)
++ return 2; // start of block, keep searching
++ }
++ return b;
++}
++
++// ----------------------------------------------------------------------
++
++/*! @brief Returns "true" if one bit is set in the block [left, right]
++ Function check for block varieties
++ @internal
++*/
++inline
++bool block_any_range(const bm::word_t* const BMRESTRICT block,
++ unsigned left, unsigned right) BMNOEXCEPT
++{
++ BM_ASSERT(left <= right);
++ BM_ASSERT(right < bm::gap_max_bits);
++ if (!block)
++ return false;
++ if (BM_IS_GAP(block))
++ return bm::gap_any_range(BMGAP_PTR(block), left, right);
++ if (IS_FULL_BLOCK(block))
++ return true;
++ return bm::bit_block_any_range(block, left, right);
++}
++
++// ----------------------------------------------------------------------
++
++/*! @brief Returns "true" if one bit is set in the block
++ Function check for block varieties
++ @internal
++*/
++inline
++bool block_any(const bm::word_t* const BMRESTRICT block) BMNOEXCEPT
++{
++ if (!block)
++ return false;
++ if (IS_FULL_BLOCK(block))
++ return true;
++ bool all_zero = (BM_IS_GAP(block)) ?
++ bm::gap_is_all_zero(BMGAP_PTR(block))
++ : bm::bit_is_all_zero(block);
++ return !all_zero;
++}
++
++
++
++// ----------------------------------------------------------------------
++
++// GAP blocks manipulation functions:
++
++
+ /*!
+ \brief GAP AND operation.
+
+@@ -5095,13 +5608,14 @@
+
+ @ingroup gapfunc
+ */
+-BMFORCEINLINE
++inline
+ gap_word_t* gap_operation_and(const gap_word_t* BMRESTRICT vect1,
+ const gap_word_t* BMRESTRICT vect2,
+ gap_word_t* BMRESTRICT tmp_buf,
+- unsigned& dsize)
++ unsigned& dsize) BMNOEXCEPT
+ {
+- bm::gap_buff_op(tmp_buf, vect1, 0, vect2, 0, bm::and_op, dsize);
++ bm::gap_buff_op<bm::gap_word_t, bm::and_func>(
++ tmp_buf, vect1, 0, vect2, 0, dsize);
+ return tmp_buf;
+ }
+
+@@ -5119,11 +5633,11 @@
+
+ @ingroup gapfunc
+ */
+-BMFORCEINLINE
++inline
+ unsigned gap_operation_any_and(const gap_word_t* BMRESTRICT vect1,
+- const gap_word_t* BMRESTRICT vect2)
++ const gap_word_t* BMRESTRICT vect2) BMNOEXCEPT
+ {
+- return gap_buff_any_op(vect1, 0, vect2, 0, and_op);
++ return gap_buff_any_op<bm::gap_word_t, bm::and_func>(vect1, 0, vect2, 0);
+ }
+
+
+@@ -5138,9 +5652,9 @@
+ */
+ inline
+ unsigned gap_count_and(const gap_word_t* BMRESTRICT vect1,
+- const gap_word_t* BMRESTRICT vect2)
++ const gap_word_t* BMRESTRICT vect2) BMNOEXCEPT
+ {
+- return gap_buff_count_op(vect1, vect2, and_op);
++ return bm::gap_buff_count_op<bm::gap_word_t, bm::and_func>(vect1, vect2);
+ }
+
+
+@@ -5165,9 +5679,10 @@
+ gap_word_t* gap_operation_xor(const gap_word_t* BMRESTRICT vect1,
+ const gap_word_t* BMRESTRICT vect2,
+ gap_word_t* BMRESTRICT tmp_buf,
+- unsigned& dsize)
++ unsigned& dsize) BMNOEXCEPT
+ {
+- gap_buff_op(tmp_buf, vect1, 0, vect2, 0, bm::xor_op, dsize);
++ bm::gap_buff_op<bm::gap_word_t, bm::xor_func>(
++ tmp_buf, vect1, 0, vect2, 0, dsize);
+ return tmp_buf;
+ }
+
+@@ -5178,9 +5693,10 @@
+ bool gap_operation_dry_xor(const gap_word_t* BMRESTRICT vect1,
+ const gap_word_t* BMRESTRICT vect2,
+ unsigned& dsize,
+- unsigned limit)
++ unsigned limit) BMNOEXCEPT
+ {
+- return gap_buff_dry_op(vect1, vect2, bm::xor_op, dsize, limit);
++ return
++ bm::gap_buff_dry_op<bm::gap_word_t, bm::xor_func>(vect1, vect2, dsize, limit);
+ }
+
+
+@@ -5200,9 +5716,9 @@
+ */
+ BMFORCEINLINE
+ unsigned gap_operation_any_xor(const gap_word_t* BMRESTRICT vect1,
+- const gap_word_t* BMRESTRICT vect2)
++ const gap_word_t* BMRESTRICT vect2) BMNOEXCEPT
+ {
+- return gap_buff_any_op(vect1, 0, vect2, 0, bm::xor_op);
++ return gap_buff_any_op<bm::gap_word_t, bm::xor_func>(vect1, 0, vect2, 0);
+ }
+
+ /*!
+@@ -5214,11 +5730,11 @@
+
+ @ingroup gapfunc
+ */
+-BMFORCEINLINE
++BMFORCEINLINE
+ unsigned gap_count_xor(const gap_word_t* BMRESTRICT vect1,
+- const gap_word_t* BMRESTRICT vect2)
++ const gap_word_t* BMRESTRICT vect2) BMNOEXCEPT
+ {
+- return gap_buff_count_op(vect1, vect2, bm::xor_op);
++ return bm::gap_buff_count_op<bm::gap_word_t, bm::xor_func>(vect1, vect2);
+ }
+
+
+@@ -5243,10 +5759,10 @@
+ gap_word_t* gap_operation_or(const gap_word_t* BMRESTRICT vect1,
+ const gap_word_t* BMRESTRICT vect2,
+ gap_word_t* BMRESTRICT tmp_buf,
+- unsigned& dsize)
++ unsigned& dsize) BMNOEXCEPT
+ {
+- gap_buff_op(tmp_buf, vect1, 1, vect2, 1, bm::and_op, dsize);
+- gap_invert(tmp_buf);
++ bm::gap_buff_op<bm::gap_word_t, bm::and_func>(tmp_buf, vect1, 1, vect2, 1, dsize);
++ bm::gap_invert(tmp_buf);
+ return tmp_buf;
+ }
+
+@@ -5261,9 +5777,9 @@
+ */
+ BMFORCEINLINE
+ unsigned gap_count_or(const gap_word_t* BMRESTRICT vect1,
+- const gap_word_t* BMRESTRICT vect2)
++ const gap_word_t* BMRESTRICT vect2) BMNOEXCEPT
+ {
+- return gap_buff_count_op(vect1, vect2, bm::or_op);
++ return gap_buff_count_op<bm::gap_word_t, bm::or_func>(vect1, vect2);
+ }
+
+
+@@ -5285,12 +5801,14 @@
+
+ @ingroup gapfunc
+ */
+-inline gap_word_t* gap_operation_sub(const gap_word_t* BMRESTRICT vect1,
+- const gap_word_t* BMRESTRICT vect2,
+- gap_word_t* BMRESTRICT tmp_buf,
+- unsigned& dsize)
++inline
++gap_word_t* gap_operation_sub(const gap_word_t* BMRESTRICT vect1,
++ const gap_word_t* BMRESTRICT vect2,
++ gap_word_t* BMRESTRICT tmp_buf,
++ unsigned& dsize) BMNOEXCEPT
+ {
+- gap_buff_op(tmp_buf, vect1, 0, vect2, 1, and_op, dsize);
++ bm::gap_buff_op<bm::gap_word_t, bm::and_func>( // no bug here
++ tmp_buf, vect1, 0, vect2, 1, dsize);
+ return tmp_buf;
+ }
+
+@@ -5309,11 +5827,13 @@
+
+ @ingroup gapfunc
+ */
+-BMFORCEINLINE
++inline
+ unsigned gap_operation_any_sub(const gap_word_t* BMRESTRICT vect1,
+- const gap_word_t* BMRESTRICT vect2)
++ const gap_word_t* BMRESTRICT vect2) BMNOEXCEPT
+ {
+- return gap_buff_any_op(vect1, 0, vect2, 1, bm::and_op);
++ return
++ bm::gap_buff_any_op<bm::gap_word_t, bm::and_func>( // no bug here
++ vect1, 0, vect2, 1);
+ }
+
+
+@@ -5328,9 +5848,9 @@
+ */
+ BMFORCEINLINE
+ unsigned gap_count_sub(const gap_word_t* BMRESTRICT vect1,
+- const gap_word_t* BMRESTRICT vect2)
++ const gap_word_t* BMRESTRICT vect2) BMNOEXCEPT
+ {
+- return gap_buff_count_op(vect1, vect2, bm::sub_op);
++ return bm::gap_buff_count_op<bm::gap_word_t, bm::sub_func>(vect1, vect2);
+ }
+
+
+@@ -5348,7 +5868,8 @@
+ @ingroup bitfunc
+ */
+ inline
+-void bit_block_copy(bm::word_t* BMRESTRICT dst, const bm::word_t* BMRESTRICT src)
++void bit_block_copy(bm::word_t* BMRESTRICT dst,
++ const bm::word_t* BMRESTRICT src) BMNOEXCEPT
+ {
+ #ifdef BMVECTOPT
+ VECT_COPY_BLOCK(dst, src);
+@@ -5366,7 +5887,8 @@
+ @ingroup bitfunc
+ */
+ inline
+-void bit_block_stream(bm::word_t* BMRESTRICT dst, const bm::word_t* BMRESTRICT src)
++void bit_block_stream(bm::word_t* BMRESTRICT dst,
++ const bm::word_t* BMRESTRICT src) BMNOEXCEPT
+ {
+ #ifdef VECT_STREAM_BLOCK
+ VECT_STREAM_BLOCK(dst, src);
+@@ -5388,7 +5910,8 @@
+ @ingroup bitfunc
+ */
+ inline
+-bm::id64_t bit_block_and(bm::word_t* BMRESTRICT dst, const bm::word_t* BMRESTRICT src)
++bm::id64_t bit_block_and(bm::word_t* BMRESTRICT dst,
++ const bm::word_t* BMRESTRICT src) BMNOEXCEPT
+ {
+ BM_ASSERT(dst);
+ BM_ASSERT(src);
+@@ -5428,7 +5951,7 @@
+ inline
+ bm::id64_t bit_block_and(bm::word_t* BMRESTRICT dst,
+ const bm::word_t* BMRESTRICT src,
+- bm::id64_t digest)
++ bm::id64_t digest) BMNOEXCEPT
+ {
+ BM_ASSERT(dst);
+ BM_ASSERT(src);
+@@ -5486,7 +6009,7 @@
+ const bm::word_t* BMRESTRICT src1,
+ const bm::word_t* BMRESTRICT src2,
+ const bm::word_t* BMRESTRICT src3,
+- bm::id64_t digest)
++ bm::id64_t digest) BMNOEXCEPT
+ {
+ BM_ASSERT(dst);
+ BM_ASSERT(src0 && src1 && src2 && src3);
+@@ -5551,7 +6074,7 @@
+ bm::id64_t bit_block_and_2way(bm::word_t* BMRESTRICT dst,
+ const bm::word_t* BMRESTRICT src1,
+ const bm::word_t* BMRESTRICT src2,
+- bm::id64_t digest)
++ bm::id64_t digest) BMNOEXCEPT
+ {
+ BM_ASSERT(dst);
+ BM_ASSERT(src1 && src2);
+@@ -5612,7 +6135,7 @@
+ */
+ inline
+ unsigned bit_block_and_count(const bm::word_t* BMRESTRICT src1,
+- const bm::word_t* BMRESTRICT src2)
++ const bm::word_t* BMRESTRICT src2) BMNOEXCEPT
+ {
+ unsigned count;
+ const bm::word_t* src1_end = src1 + bm::set_block_size;
+@@ -5661,7 +6184,7 @@
+ */
+ inline
+ unsigned bit_block_and_any(const bm::word_t* src1,
+- const bm::word_t* src2)
++ const bm::word_t* src2) BMNOEXCEPT
+ {
+ unsigned count = 0;
+ const bm::word_t* src1_end = src1 + bm::set_block_size;
+@@ -5691,7 +6214,7 @@
+ */
+ inline
+ unsigned bit_block_xor_count(const bm::word_t* BMRESTRICT src1,
+- const bm::word_t* BMRESTRICT src2)
++ const bm::word_t* BMRESTRICT src2) BMNOEXCEPT
+ {
+ unsigned count;
+ const bm::word_t* BMRESTRICT src1_end = src1 + bm::set_block_size;
+@@ -5740,7 +6263,7 @@
+ */
+ inline
+ unsigned bit_block_xor_any(const bm::word_t* BMRESTRICT src1,
+- const bm::word_t* BMRESTRICT src2)
++ const bm::word_t* BMRESTRICT src2) BMNOEXCEPT
+ {
+ unsigned count = 0;
+ const bm::word_t* BMRESTRICT src1_end = src1 + bm::set_block_size;
+@@ -5767,7 +6290,7 @@
+ */
+ inline
+ unsigned bit_block_sub_count(const bm::word_t* BMRESTRICT src1,
+- const bm::word_t* BMRESTRICT src2)
++ const bm::word_t* BMRESTRICT src2) BMNOEXCEPT
+ {
+ unsigned count;
+ const bm::word_t* BMRESTRICT src1_end = src1 + bm::set_block_size;
+@@ -5815,7 +6338,7 @@
+ */
+ inline
+ unsigned bit_block_sub_any(const bm::word_t* BMRESTRICT src1,
+- const bm::word_t* BMRESTRICT src2)
++ const bm::word_t* BMRESTRICT src2) BMNOEXCEPT
+ {
+ unsigned count = 0;
+ const bm::word_t* BMRESTRICT src1_end = src1 + bm::set_block_size;
+@@ -5844,7 +6367,7 @@
+ */
+ inline
+ unsigned bit_block_or_count(const bm::word_t* src1,
+- const bm::word_t* src2)
++ const bm::word_t* src2) BMNOEXCEPT
+ {
+ unsigned count;
+ const bm::word_t* src1_end = src1 + bm::set_block_size;
+@@ -5892,7 +6415,7 @@
+ */
+ inline
+ unsigned bit_block_or_any(const bm::word_t* BMRESTRICT src1,
+- const bm::word_t* BMRESTRICT src2)
++ const bm::word_t* BMRESTRICT src2) BMNOEXCEPT
+ {
+ unsigned count = 0;
+ const bm::word_t* BMRESTRICT src1_end = src1 + bm::set_block_size;
+@@ -5924,7 +6447,7 @@
+ @ingroup bitfunc
+ */
+ inline bm::word_t* bit_operation_and(bm::word_t* BMRESTRICT dst,
+- const bm::word_t* BMRESTRICT src)
++ const bm::word_t* BMRESTRICT src) BMNOEXCEPT
+ {
+ BM_ASSERT(dst || src);
+
+@@ -5988,7 +6511,7 @@
+ */
+ inline
+ bm::id_t bit_operation_and_count(const bm::word_t* BMRESTRICT src1,
+- const bm::word_t* BMRESTRICT src2)
++ const bm::word_t* BMRESTRICT src2) BMNOEXCEPT
+ {
+ if (IS_EMPTY_BLOCK(src1) || IS_EMPTY_BLOCK(src2))
+ return 0;
+@@ -6012,7 +6535,7 @@
+ */
+ inline
+ bm::id_t bit_operation_and_any(const bm::word_t* BMRESTRICT src1,
+- const bm::word_t* BMRESTRICT src2)
++ const bm::word_t* BMRESTRICT src2) BMNOEXCEPT
+ {
+ if (IS_EMPTY_BLOCK(src1) || IS_EMPTY_BLOCK(src2))
+ return 0;
+@@ -6037,7 +6560,7 @@
+ */
+ inline
+ bm::id_t bit_operation_sub_count(const bm::word_t* BMRESTRICT src1,
+- const bm::word_t* BMRESTRICT src2)
++ const bm::word_t* BMRESTRICT src2) BMNOEXCEPT
+ {
+ if (src1 == src2)
+ return 0;
+@@ -6074,7 +6597,7 @@
+ */
+ inline
+ bm::id_t bit_operation_sub_count_inv(const bm::word_t* BMRESTRICT src1,
+- const bm::word_t* BMRESTRICT src2)
++ const bm::word_t* BMRESTRICT src2) BMNOEXCEPT
+ {
+ return bit_operation_sub_count(src2, src1);
+ }
+@@ -6092,7 +6615,7 @@
+ */
+ inline
+ bm::id_t bit_operation_sub_any(const bm::word_t* BMRESTRICT src1,
+- const bm::word_t* BMRESTRICT src2)
++ const bm::word_t* BMRESTRICT src2) BMNOEXCEPT
+ {
+ if (IS_EMPTY_BLOCK(src1))
+ return 0;
+@@ -6127,7 +6650,7 @@
+ */
+ inline
+ bm::id_t bit_operation_or_count(const bm::word_t* BMRESTRICT src1,
+- const bm::word_t* BMRESTRICT src2)
++ const bm::word_t* BMRESTRICT src2) BMNOEXCEPT
+ {
+ if (IS_FULL_BLOCK(src1) || IS_FULL_BLOCK(src2))
+ return bm::gap_max_bits;
+@@ -6164,7 +6687,7 @@
+ */
+ inline
+ bm::id_t bit_operation_or_any(const bm::word_t* BMRESTRICT src1,
+- const bm::word_t* BMRESTRICT src2)
++ const bm::word_t* BMRESTRICT src2) BMNOEXCEPT
+ {
+ if (IS_EMPTY_BLOCK(src1))
+ {
+@@ -6197,7 +6720,7 @@
+ */
+ inline
+ bool bit_block_or(bm::word_t* BMRESTRICT dst,
+- const bm::word_t* BMRESTRICT src)
++ const bm::word_t* BMRESTRICT src) BMNOEXCEPT
+ {
+ #ifdef BMVECTOPT
+ return VECT_OR_BLOCK(dst, src);
+@@ -6235,7 +6758,7 @@
+ inline
+ bool bit_block_or_2way(bm::word_t* BMRESTRICT dst,
+ const bm::word_t* BMRESTRICT src1,
+- const bm::word_t* BMRESTRICT src2)
++ const bm::word_t* BMRESTRICT src2) BMNOEXCEPT
+ {
+ #ifdef BMVECTOPT
+ return VECT_OR_BLOCK_2WAY(dst, src1, src2);
+@@ -6274,7 +6797,7 @@
+ inline
+ bm::id64_t bit_block_xor_2way(bm::word_t* BMRESTRICT dst,
+ const bm::word_t* BMRESTRICT src1,
+- const bm::word_t* BMRESTRICT src2)
++ const bm::word_t* BMRESTRICT src2) BMNOEXCEPT
+ {
+ #ifdef BMVECTOPT
+ return VECT_XOR_BLOCK_2WAY(dst, src1, src2);
+@@ -6315,7 +6838,7 @@
+ inline
+ bool bit_block_or_3way(bm::word_t* BMRESTRICT dst,
+ const bm::word_t* BMRESTRICT src1,
+- const bm::word_t* BMRESTRICT src2)
++ const bm::word_t* BMRESTRICT src2) BMNOEXCEPT
+ {
+ #ifdef BMVECTOPT
+ return VECT_OR_BLOCK_3WAY(dst, src1, src2);
+@@ -6361,7 +6884,7 @@
+ const bm::word_t* BMRESTRICT src1,
+ const bm::word_t* BMRESTRICT src2,
+ const bm::word_t* BMRESTRICT src3,
+- const bm::word_t* BMRESTRICT src4)
++ const bm::word_t* BMRESTRICT src4) BMNOEXCEPT
+ {
+ #ifdef BMVECTOPT
+ return VECT_OR_BLOCK_5WAY(dst, src1, src2, src3, src4);
+@@ -6407,7 +6930,7 @@
+ */
+ inline
+ bm::word_t* bit_operation_or(bm::word_t* BMRESTRICT dst,
+- const bm::word_t* BMRESTRICT src)
++ const bm::word_t* BMRESTRICT src) BMNOEXCEPT
+ {
+ BM_ASSERT(dst || src);
+
+@@ -6467,7 +6990,7 @@
+ */
+ inline
+ bm::id64_t bit_block_sub(bm::word_t* BMRESTRICT dst,
+- const bm::word_t* BMRESTRICT src)
++ const bm::word_t* BMRESTRICT src) BMNOEXCEPT
+ {
+ #ifdef BMVECTOPT
+ bm::id64_t acc = VECT_SUB_BLOCK(dst, src);
+@@ -6504,7 +7027,7 @@
+ inline
+ bm::id64_t bit_block_sub(bm::word_t* BMRESTRICT dst,
+ const bm::word_t* BMRESTRICT src,
+- bm::id64_t digest)
++ bm::id64_t digest) BMNOEXCEPT
+ {
+ BM_ASSERT(dst);
+ BM_ASSERT(src);
+@@ -6565,7 +7088,7 @@
+ bm::id64_t bit_block_sub_2way(bm::word_t* BMRESTRICT dst,
+ const bm::word_t* BMRESTRICT src1,
+ const bm::word_t* BMRESTRICT src2,
+- bm::id64_t digest)
++ bm::id64_t digest) BMNOEXCEPT
+ {
+ BM_ASSERT(dst);
+ BM_ASSERT(src1 && src2);
+@@ -6630,7 +7153,7 @@
+ */
+ inline
+ bm::word_t* bit_operation_sub(bm::word_t* BMRESTRICT dst,
+- const bm::word_t* BMRESTRICT src)
++ const bm::word_t* BMRESTRICT src) BMNOEXCEPT
+ {
+ BM_ASSERT(dst || src);
+
+@@ -6688,7 +7211,7 @@
+ */
+ inline
+ bm::id64_t bit_block_xor(bm::word_t* BMRESTRICT dst,
+- const bm::word_t* BMRESTRICT src)
++ const bm::word_t* BMRESTRICT src) BMNOEXCEPT
+ {
+ BM_ASSERT(dst);
+ BM_ASSERT(src);
+@@ -6724,7 +7247,7 @@
+ */
+ inline
+ void bit_andnot_arr_ffmask(bm::word_t* BMRESTRICT dst,
+- const bm::word_t* BMRESTRICT src)
++ const bm::word_t* BMRESTRICT src) BMNOEXCEPT
+ {
+ const bm::word_t* BMRESTRICT src_end = src + bm::set_block_size;
+ #ifdef BMVECTOPT
+@@ -6759,7 +7282,7 @@
+ */
+ inline
+ bm::word_t* bit_operation_xor(bm::word_t* BMRESTRICT dst,
+- const bm::word_t* BMRESTRICT src)
++ const bm::word_t* BMRESTRICT src) BMNOEXCEPT
+ {
+ BM_ASSERT(dst || src);
+ if (src == dst) return 0; // XOR rule
+@@ -6797,7 +7320,7 @@
+ */
+ inline
+ bm::id_t bit_operation_xor_count(const bm::word_t* BMRESTRICT src1,
+- const bm::word_t* BMRESTRICT src2)
++ const bm::word_t* BMRESTRICT src2) BMNOEXCEPT
+ {
+ if (src1 == src2)
+ return 0;
+@@ -6829,7 +7352,7 @@
+ */
+ inline
+ bm::id_t bit_operation_xor_any(const bm::word_t* BMRESTRICT src1,
+- const bm::word_t* BMRESTRICT src2)
++ const bm::word_t* BMRESTRICT src2) BMNOEXCEPT
+ {
+ if (src1 == src2)
+ return 0;
+@@ -6854,7 +7377,7 @@
+ @ingroup bitfunc
+ */
+ template<class T>
+-unsigned bit_count_nonzero_size(const T* blk, unsigned data_size)
++unsigned bit_count_nonzero_size(const T* blk, unsigned data_size) BMNOEXCEPT
+ {
+ BM_ASSERT(blk && data_size);
+ unsigned count = 0;
+@@ -6914,7 +7437,8 @@
+ @ingroup bitfunc
+ */
+ inline
+-unsigned bit_block_find(const bm::word_t* block, unsigned nbit, unsigned* pos)
++unsigned bit_block_find(const bm::word_t* BMRESTRICT block,
++ unsigned nbit, unsigned* BMRESTRICT pos) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+ BM_ASSERT(pos);
+@@ -6934,7 +7458,7 @@
+ if (w)
+ {
+ bit_pos = bm::bit_scan_forward32(w); // trailing zeros
+- *pos = unsigned(bit_pos + (nword * 8u * sizeof(bm::word_t)));
++ *pos = unsigned(bit_pos + (nword * 8u * unsigned(sizeof(bm::word_t))));
+ return 1;
+ }
+
+@@ -6944,7 +7468,7 @@
+ if (w)
+ {
+ bit_pos = bm::bit_scan_forward32(w); // trailing zeros
+- *pos = unsigned(bit_pos + (i * 8u * sizeof(bm::word_t)));
++ *pos = unsigned(bit_pos + (i * 8u * unsigned(sizeof(bm::word_t))));
+ return w;
+ }
+ } // for i
+@@ -6952,6 +7476,8 @@
+ }
+
+
++
++
+ /*!
+ \brief BIT block find the last set bit (backward search)
+
+@@ -6962,7 +7488,8 @@
+ @ingroup bitfunc
+ */
+ inline
+-unsigned bit_find_last(const bm::word_t* block, unsigned* last)
++unsigned bit_find_last(const bm::word_t* BMRESTRICT block,
++ unsigned* BMRESTRICT last) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+ BM_ASSERT(last);
+@@ -6975,7 +7502,7 @@
+ if (w)
+ {
+ unsigned idx = bm::bit_scan_reverse(w);
+- *last = unsigned(idx + (i * 8u * sizeof(bm::word_t)));
++ *last = unsigned(idx + (i * 8u * unsigned(sizeof(bm::word_t))));
+ return w;
+ }
+ if (i == 0)
+@@ -6995,7 +7522,8 @@
+ @internal
+ */
+ inline
+-bool bit_find_first(const bm::word_t* block, unsigned* pos)
++bool bit_find_first(const bm::word_t* BMRESTRICT block,
++ unsigned* BMRESTRICT pos) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+ BM_ASSERT(pos);
+@@ -7009,7 +7537,7 @@
+ if (w)
+ {
+ unsigned idx = bm::bit_scan_forward32(w); // trailing zeros
+- *pos = unsigned(idx + (i * 8u * sizeof(bm::word_t)));
++ *pos = unsigned(idx + (i * 8u * unsigned(sizeof(bm::word_t))));
+ return w;
+ }
+ } // for i
+@@ -7029,9 +7557,9 @@
+ @ingroup bitfunc
+ */
+ inline
+-unsigned bit_find_first(const bm::word_t* block,
+- unsigned* first,
+- bm::id64_t digest)
++unsigned bit_find_first(const bm::word_t* BMRESTRICT block,
++ unsigned* BMRESTRICT first,
++ bm::id64_t digest) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+ BM_ASSERT(first);
+@@ -7047,7 +7575,7 @@
+ if (w)
+ {
+ unsigned idx = bit_scan_forward32(w); // trailing zeros
+- *first = unsigned(idx + (i * 8u * sizeof(bm::word_t)));
++ *first = unsigned(idx + (i * 8u * unsigned(sizeof(bm::word_t))));
+ return w;
+ }
+ } // for i
+@@ -7067,9 +7595,9 @@
+ @ingroup bitfunc
+ */
+ inline
+-bool bit_find_first_if_1(const bm::word_t* block,
+- unsigned* first,
+- bm::id64_t digest)
++bool bit_find_first_if_1(const bm::word_t* BMRESTRICT block,
++ unsigned* BMRESTRICT first,
++ bm::id64_t digest) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+ BM_ASSERT(first);
+@@ -7127,7 +7655,7 @@
+ SIZE_TYPE bit_find_rank(const bm::word_t* const block,
+ SIZE_TYPE rank,
+ unsigned nbit_from,
+- unsigned& nbit_pos)
++ unsigned& nbit_pos) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+ BM_ASSERT(rank);
+@@ -7206,7 +7734,7 @@
+ SIZE_TYPE block_find_rank(const bm::word_t* const block,
+ SIZE_TYPE rank,
+ unsigned nbit_from,
+- unsigned& nbit_pos)
++ unsigned& nbit_pos) BMNOEXCEPT
+ {
+ if (BM_IS_GAP(block))
+ {
+@@ -7230,7 +7758,7 @@
+ bm::set_representation best_representation(unsigned bit_count,
+ unsigned total_possible_bitcount,
+ unsigned gap_count,
+- unsigned block_size)
++ unsigned block_size) BMNOEXCEPT
+ {
+ unsigned arr_size = unsigned(sizeof(bm::gap_word_t) * bit_count + sizeof(bm::gap_word_t));
+ unsigned gap_size = unsigned(sizeof(bm::gap_word_t) * gap_count + sizeof(bm::gap_word_t));
+@@ -7268,15 +7796,16 @@
+ const unsigned* BMRESTRICT src,
+ bm::id_t bits,
+ unsigned dest_len,
+- unsigned mask = 0)
++ unsigned mask = 0) BMNOEXCEPT
+ {
+ T* BMRESTRICT pcurr = dest;
+- for (unsigned bit_idx=0; bit_idx < bits; ++src,bit_idx += unsigned(sizeof(*src) * 8))
++ for (unsigned bit_idx=0; bit_idx < bits;
++ ++src,bit_idx += unsigned(sizeof(*src) * 8))
+ {
+ unsigned val = *src ^ mask; // invert value by XOR 0xFF..
+ if (val == 0)
+ continue;
+- if (pcurr + sizeof(val)*8 >= dest + dest_len) // insufficient space
++ if (pcurr + unsigned(sizeof(val)*8) >= dest + dest_len) // insufficient space
+ return 0;
+ // popscan loop to decode bits in a word
+ while (val)
+@@ -7299,7 +7828,7 @@
+ @internal
+ */
+ inline
+-bool check_block_zero(const bm::word_t* blk, bool deep_scan)
++bool check_block_zero(const bm::word_t* blk, bool deep_scan) BMNOEXCEPT
+ {
+ if (!blk) return true;
+ if (IS_FULL_BLOCK(blk)) return false;
+@@ -7323,7 +7852,7 @@
+ @internal
+ */
+ inline
+-bool check_block_one(const bm::word_t* blk, bool deep_scan)
++bool check_block_one(const bm::word_t* blk, bool deep_scan) BMNOEXCEPT
+ {
+ if (blk == 0) return false;
+
+@@ -7348,7 +7877,7 @@
+ template<typename T>
+ unsigned gap_overhead(const T* length,
+ const T* length_end,
+- const T* glevel_len)
++ const T* glevel_len) BMNOEXCEPT
+ {
+ BM_ASSERT(length && length_end && glevel_len);
+
+@@ -7375,7 +7904,7 @@
+ template<typename T>
+ bool improve_gap_levels(const T* length,
+ const T* length_end,
+- T* glevel_len)
++ T* glevel_len) BMNOEXCEPT
+ {
+ BM_ASSERT(length && length_end && glevel_len);
+
+@@ -7473,7 +8002,7 @@
+ inline
+ bool block_find_first_diff(const bm::word_t* BMRESTRICT blk,
+ const bm::word_t* BMRESTRICT arg_blk,
+- unsigned* BMRESTRICT pos)
++ unsigned* BMRESTRICT pos) BMNOEXCEPT
+ {
+ // If one block is zero we check if the other one has at least
+ // one bit ON
+@@ -7568,7 +8097,7 @@
+ bitblock_get_adapter(const bm::word_t* bit_block) : b_(bit_block) {}
+
+ BMFORCEINLINE
+- bm::word_t get_32() { return *b_++; }
++ bm::word_t get_32() BMNOEXCEPT { return *b_++; }
+ private:
+ const bm::word_t* b_;
+ };
+@@ -7597,9 +8126,9 @@
+ public:
+ bitblock_sum_adapter() : sum_(0) {}
+ BMFORCEINLINE
+- void push_back(bm::word_t w) { this->sum_+= w; }
++ void push_back(bm::word_t w) BMNOEXCEPT { this->sum_+= w; }
+ /// Get accumulated sum
+- bm::word_t sum() const { return this->sum_; }
++ bm::word_t sum() const BMNOEXCEPT { return this->sum_; }
+ private:
+ bm::word_t sum_;
+ };
+@@ -7619,7 +8148,7 @@
+ cnt_(0)
+ {}
+
+- bm::word_t get_32()
++ bm::word_t get_32() BMNOEXCEPT
+ {
+ if (cnt_ < from_ || cnt_ > to_)
+ {
+@@ -7645,7 +8174,7 @@
+ void bit_recomb(It1& it1, It2& it2,
+ BinaryOp& op,
+ Encoder& enc,
+- unsigned block_size = bm::set_block_size)
++ unsigned block_size = bm::set_block_size) BMNOEXCEPT
+ {
+ for (unsigned i = 0; i < block_size; ++i)
+ {
+@@ -7659,37 +8188,37 @@
+ /// Bit AND functor
+ template<typename W> struct bit_AND
+ {
+- W operator()(W w1, W w2) { return w1 & w2; }
++ W operator()(W w1, W w2) BMNOEXCEPT { return w1 & w2; }
+ };
+
+ /// Bit OR functor
+ template<typename W> struct bit_OR
+ {
+- W operator()(W w1, W w2) { return w1 | w2; }
++ W operator()(W w1, W w2) BMNOEXCEPT { return w1 | w2; }
+ };
+
+ /// Bit SUB functor
+ template<typename W> struct bit_SUB
+ {
+- W operator()(W w1, W w2) { return w1 & ~w2; }
++ W operator()(W w1, W w2) BMNOEXCEPT { return w1 & ~w2; }
+ };
+
+ /// Bit XOR functor
+ template<typename W> struct bit_XOR
+ {
+- W operator()(W w1, W w2) { return w1 ^ w2; }
++ W operator()(W w1, W w2) BMNOEXCEPT { return w1 ^ w2; }
+ };
+
+ /// Bit ASSIGN functor
+ template<typename W> struct bit_ASSIGN
+ {
+- W operator()(W, W w2) { return w2; }
++ W operator()(W, W w2) BMNOEXCEPT { return w2; }
+ };
+
+ /// Bit COUNT functor
+ template<typename W> struct bit_COUNT
+ {
+- W operator()(W w1, W w2)
++ W operator()(W w1, W w2) BMNOEXCEPT
+ {
+ w1 = 0;
+ BM_INCWORD_BITCOUNT(w1, w2);
+@@ -7700,7 +8229,7 @@
+ /// Bit COUNT AND functor
+ template<typename W> struct bit_COUNT_AND
+ {
+- W operator()(W w1, W w2)
++ W operator()(W w1, W w2) BMNOEXCEPT
+ {
+ W r = 0;
+ BM_INCWORD_BITCOUNT(r, w1 & w2);
+@@ -7711,7 +8240,7 @@
+ /// Bit COUNT XOR functor
+ template<typename W> struct bit_COUNT_XOR
+ {
+- W operator()(W w1, W w2)
++ W operator()(W w1, W w2) BMNOEXCEPT
+ {
+ W r = 0;
+ BM_INCWORD_BITCOUNT(r, w1 ^ w2);
+@@ -7722,7 +8251,7 @@
+ /// Bit COUNT OR functor
+ template<typename W> struct bit_COUNT_OR
+ {
+- W operator()(W w1, W w2)
++ W operator()(W w1, W w2) BMNOEXCEPT
+ {
+ W r = 0;
+ BM_INCWORD_BITCOUNT(r, w1 | w2);
+@@ -7734,7 +8263,7 @@
+ /// Bit COUNT SUB AB functor
+ template<typename W> struct bit_COUNT_SUB_AB
+ {
+- W operator()(W w1, W w2)
++ W operator()(W w1, W w2) BMNOEXCEPT
+ {
+ W r = 0;
+ BM_INCWORD_BITCOUNT(r, w1 & (~w2));
+@@ -7745,7 +8274,7 @@
+ /// Bit SUB BA functor
+ template<typename W> struct bit_COUNT_SUB_BA
+ {
+- W operator()(W w1, W w2)
++ W operator()(W w1, W w2) BMNOEXCEPT
+ {
+ W r = 0;
+ BM_INCWORD_BITCOUNT(r, w2 & (~w1));
+@@ -7756,7 +8285,7 @@
+ /// Bit COUNT A functor
+ template<typename W> struct bit_COUNT_A
+ {
+- W operator()(W w1, W )
++ W operator()(W w1, W ) BMNOEXCEPT
+ {
+ W r = 0;
+ BM_INCWORD_BITCOUNT(r, w1);
+@@ -7767,7 +8296,7 @@
+ /// Bit COUNT B functor
+ template<typename W> struct bit_COUNT_B
+ {
+- W operator()(W, W w2)
++ W operator()(W, W w2) BMNOEXCEPT
+ {
+ W r = 0;
+ BM_INCWORD_BITCOUNT(r, w2);
+@@ -7858,8 +8387,11 @@
+ 0, // set_COUNT_B
+ };
+
+-
+-const unsigned short set_bitscan_wave_size = 2;
++/**
++ Size of bit decode wave in words
++ @internal
++ */
++const unsigned short set_bitscan_wave_size = 4;
+ /*!
+ \brief Unpacks word wave (Nx 32-bit words)
+ \param w_ptr - pointer on wave start
+@@ -7870,7 +8402,9 @@
+ @internal
+ */
+ inline
+-unsigned short bitscan_wave(const bm::word_t* w_ptr, unsigned char* bits)
++unsigned short
++bitscan_wave(const bm::word_t* BMRESTRICT w_ptr,
++ unsigned char* BMRESTRICT bits) BMNOEXCEPT
+ {
+ bm::word_t w0, w1;
+ unsigned short cnt0;
+@@ -7882,12 +8416,20 @@
+ // combine into 64-bit word and scan (when HW popcnt64 is available)
+ bm::id64_t w = (bm::id64_t(w1) << 32) | w0;
+ cnt0 = (unsigned short) bm::bitscan_popcnt64(w, bits);
++
++ w0 = w_ptr[2];
++ w1 = w_ptr[3];
++ w = (bm::id64_t(w1) << 32) | w0;
++ cnt0 += bm::bitscan_popcnt64(w, bits + cnt0, 64);
+ #else
+- unsigned short cnt1;
+ // decode wave as two 32-bit bitscan decodes
+- cnt0 = w0 ? bm::bitscan_popcnt(w0, bits) : 0;
+- cnt1 = w1 ? bm::bitscan_popcnt(w1, bits + cnt0, 32) : 0;
+- cnt0 = (unsigned short)(cnt0 + cnt1);
++ cnt0 = bm::bitscan_popcnt(w0, bits);
++ cnt0 += bm::bitscan_popcnt(w1, bits + cnt0, 32);
++
++ w0 = w_ptr[2];
++ w1 = w_ptr[3];
++ cnt0 += bm::bitscan_popcnt(w0, bits + cnt0, 64);
++ cnt0 += bm::bitscan_popcnt(w1, bits + cnt0, 64+32);
+ #endif
+ return cnt0;
+ }
+@@ -7899,9 +8441,11 @@
+ @internal
+ */
+ inline
+-void bit_block_gather_scatter(unsigned* arr, const bm::word_t* blk,
+- const unsigned* idx, unsigned size, unsigned start,
+- unsigned bit_idx)
++void bit_block_gather_scatter(unsigned* BMRESTRICT arr,
++ const bm::word_t* BMRESTRICT blk,
++ const unsigned* BMRESTRICT idx,
++ unsigned size, unsigned start,
++ unsigned bit_idx) BMNOEXCEPT
+ {
+ typedef unsigned TRGW;
+ typedef unsigned IDX;
+@@ -7930,8 +8474,10 @@
+ @internal
+ */
+ template<typename TRGW, typename IDX, typename SZ>
+-void bit_block_gather_scatter(TRGW* arr, const bm::word_t* blk,
+- const IDX* idx, SZ size, SZ start, unsigned bit_idx)
++void bit_block_gather_scatter(TRGW* BMRESTRICT arr,
++ const bm::word_t* BMRESTRICT blk,
++ const IDX* BMRESTRICT idx,
++ SZ size, SZ start, unsigned bit_idx) BMNOEXCEPT
+ {
+ // TODO: SIMD for 64-bit index sizes and 64-bit target value size
+ //
+@@ -7943,15 +8489,17 @@
+ {
+ const SZ base = start + k;
+ const unsigned nbitA = unsigned(idx[base] & bm::set_block_mask);
+- arr[base] |= (TRGW(bool(blk[nbitA >> bm::set_word_shift] & (mask1 << (nbitA & bm::set_word_mask)))) << bit_idx);
++ arr[base] |= (TRGW(bool(blk[nbitA >> bm::set_word_shift] &
++ (mask1 << (nbitA & bm::set_word_mask)))) << bit_idx);
+ const unsigned nbitB = unsigned(idx[base + 1] & bm::set_block_mask);
+- arr[base+1] |= (TRGW(bool(blk[nbitB >> bm::set_word_shift] & (mask1 << (nbitB & bm::set_word_mask)))) << bit_idx);
++ arr[base+1] |= (TRGW(bool(blk[nbitB >> bm::set_word_shift] &
++ (mask1 << (nbitB & bm::set_word_mask)))) << bit_idx);
+ } // for k
+-
+ for (; k < len; ++k)
+ {
+ unsigned nbit = unsigned(idx[start + k] & bm::set_block_mask);
+- arr[start + k] |= (TRGW(bool(blk[nbit >> bm::set_word_shift] & (mask1 << (nbit & bm::set_word_mask)))) << bit_idx);
++ arr[start + k] |= (TRGW(bool(blk[nbit >> bm::set_word_shift] &
++ (mask1 << (nbit & bm::set_word_mask)))) << bit_idx);
+ } // for k
+ }
+
+@@ -7968,7 +8516,8 @@
+ @internal
+ */
+ inline
+-bm::id64_t idx_arr_block_lookup_u64(const bm::id64_t* idx, bm::id64_t size, bm::id64_t nb, bm::id64_t start)
++bm::id64_t idx_arr_block_lookup_u64(const bm::id64_t* idx,
++ bm::id64_t size, bm::id64_t nb, bm::id64_t start) BMNOEXCEPT
+ {
+ BM_ASSERT(idx);
+ BM_ASSERT(start < size);
+@@ -7993,7 +8542,8 @@
+ @internal
+ */
+ inline
+-unsigned idx_arr_block_lookup_u32(const unsigned* idx, unsigned size, unsigned nb, unsigned start)
++unsigned idx_arr_block_lookup_u32(const unsigned* idx,
++ unsigned size, unsigned nb, unsigned start) BMNOEXCEPT
+ {
+ BM_ASSERT(idx);
+ BM_ASSERT(start < size);
+@@ -8027,7 +8577,7 @@
+ inline
+ void set_block_bits_u64(bm::word_t* BMRESTRICT block,
+ const bm::id64_t* BMRESTRICT idx,
+- bm::id64_t start, bm::id64_t stop)
++ bm::id64_t start, bm::id64_t stop) BMNOEXCEPT
+ {
+ // TODO: SIMD for 64-bit mode
+ for (bm::id64_t i = start; i < stop; ++i)
+@@ -8036,8 +8586,7 @@
+ unsigned nbit = unsigned(n & bm::set_block_mask);
+ unsigned nword = nbit >> bm::set_word_shift;
+ nbit &= bm::set_word_mask;
+- bm::word_t mask = (1u << nbit);
+- block[nword] |= mask;
++ block[nword] |= (1u << nbit);
+ } // for i
+ }
+
+@@ -8058,7 +8607,7 @@
+ inline
+ void set_block_bits_u32(bm::word_t* BMRESTRICT block,
+ const unsigned* BMRESTRICT idx,
+- unsigned start, unsigned stop )
++ unsigned start, unsigned stop ) BMNOEXCEPT
+ {
+ #if defined(VECT_SET_BLOCK_BITS)
+ VECT_SET_BLOCK_BITS(block, idx, start, stop);
+@@ -8069,8 +8618,7 @@
+ unsigned nbit = unsigned(n & bm::set_block_mask);
+ unsigned nword = nbit >> bm::set_word_shift;
+ nbit &= bm::set_word_mask;
+- bm::word_t mask = (1u << nbit);
+- block[nword] |= mask;
++ block[nword] |= (1u << nbit);
+ } // for i
+ #endif
+ }
+@@ -8084,7 +8632,8 @@
+ @internal
+ */
+ inline
+-bool block_ptr_array_range(bm::word_t** arr, unsigned& left, unsigned& right)
++bool block_ptr_array_range(bm::word_t** arr,
++ unsigned& left, unsigned& right) BMNOEXCEPT
+ {
+ BM_ASSERT(arr);
+
+@@ -8119,7 +8668,7 @@
+ */
+ inline
+ unsigned lower_bound_linear_u32(const unsigned* arr, unsigned target,
+- unsigned from, unsigned to)
++ unsigned from, unsigned to) BMNOEXCEPT
+ {
+ BM_ASSERT(arr);
+ BM_ASSERT(from <= to);
+@@ -8141,8 +8690,9 @@
+ @internal
+ */
+ inline
+-unsigned lower_bound_linear_u64(const unsigned long long* arr, unsigned long long target,
+- unsigned from, unsigned to)
++unsigned lower_bound_linear_u64(const unsigned long long* arr,
++ unsigned long long target,
++ unsigned from, unsigned to) BMNOEXCEPT
+ {
+ BM_ASSERT(arr);
+ BM_ASSERT(from <= to);
+@@ -8166,7 +8716,7 @@
+ */
+ inline
+ unsigned lower_bound_u32(const unsigned* arr, unsigned target,
+- unsigned from, unsigned to)
++ unsigned from, unsigned to) BMNOEXCEPT
+ {
+ BM_ASSERT(arr);
+ BM_ASSERT(from <= to);
+@@ -8200,8 +8750,9 @@
+ @internal
+ */
+ inline
+-unsigned lower_bound_u64(const unsigned long long* arr, unsigned long long target,
+- unsigned from, unsigned to)
++unsigned lower_bound_u64(const unsigned long long* arr,
++ unsigned long long target,
++ unsigned from, unsigned to) BMNOEXCEPT
+ {
+ BM_ASSERT(arr);
+ BM_ASSERT(from <= to);
+@@ -8238,7 +8789,8 @@
+ */
+ #ifdef BM64ADDR
+ inline
+-bm::id64_t block_to_global_index(unsigned i, unsigned j, unsigned block_idx)
++bm::id64_t block_to_global_index(unsigned i, unsigned j,
++ unsigned block_idx) BMNOEXCEPT
+ {
+ bm::id64_t base_idx = bm::id64_t(i) * bm::set_sub_array_size * bm::gap_max_bits;
+ base_idx += j * bm::gap_max_bits;
+@@ -8246,7 +8798,8 @@
+ }
+ #else
+ inline
+-bm::id_t block_to_global_index(unsigned i, unsigned j, unsigned block_idx)
++bm::id_t block_to_global_index(unsigned i, unsigned j,
++ unsigned block_idx) BMNOEXCEPT
+ {
+ unsigned base_idx = i * bm::set_sub_array_size * bm::gap_max_bits;
+ base_idx += j * bm::gap_max_bits;
+@@ -8274,7 +8827,7 @@
+ @internal
+ */
+ inline
+-bm::id64_t ptrp_test(ptr_payload_t ptr, bm::gap_word_t v)
++bm::id64_t ptrp_test(ptr_payload_t ptr, bm::gap_word_t v) BMNOEXCEPT
+ {
+ if (v == 0)
+ {
+Index: c++/include/util/bitset/bmdbg.h
+===================================================================
+--- a/c++/include/util/bitset/bmdbg.h (revision 90103)
++++ b/c++/include/util/bitset/bmdbg.h (revision 90104)
+@@ -510,15 +510,15 @@
+ }
+
+ template<class BV>
+-unsigned compute_serialization_size(const BV& bv)
++size_t compute_serialization_size(const BV& bv)
+ {
+ BM_DECLARE_TEMP_BLOCK(tb)
+ unsigned char* buf = 0;
+- unsigned blob_size = 0;
++ typename BV::size_type blob_size = 0;
+ try
+ {
+ bm::serializer<BV> bvs(typename BV::allocator_type(), tb);
+- bvs.set_compression_level(4);
++ //bvs.set_compression_level(4);
+
+ typename BV::statistics st;
+ bv.calc_stat(&st);
+@@ -677,12 +677,12 @@
+ const typename SV::bvector_type* bv1 = sim_vec[k].get_first();
+ const typename SV::bvector_type* bv2 = sim_vec[k].get_second();
+
+- unsigned bv_size2 = compute_serialization_size(*bv2);
++ auto bv_size2 = compute_serialization_size(*bv2);
+
+ typename SV::bvector_type bvx(*bv2);
+ bvx ^= *bv1;
+
+- unsigned bv_size_x = compute_serialization_size(bvx);
++ auto bv_size_x = compute_serialization_size(bvx);
+ if (bv_size_x < bv_size2) // true savings
+ {
+ size_t diff = bv_size2 - bv_size_x;
+@@ -904,10 +904,15 @@
+ BM_ASSERT(!fname.empty());
+
+ bm::sparse_vector_serial_layout<SV> sv_lay;
+-
++
++ bm::sparse_vector_serializer<SV> sv_serializer;
++ sv_serializer.set_xor_ref(true);
++
++ sv_serializer.serialize(sv, sv_lay);
++/*
+ BM_DECLARE_TEMP_BLOCK(tb)
+ bm::sparse_vector_serialize(sv, sv_lay, tb);
+-
++*/
+ std::ofstream fout(fname.c_str(), std::ios::binary);
+ if (!fout.good())
+ {
+@@ -956,7 +961,7 @@
+ }
+
+
+-// comapre-check if sparse vector is excatly coresponds to vector
++// compare-check if sparse vector is excatly coresponds to vector
+ //
+ // returns 0 - if equal
+ // 1 - no size match
+@@ -979,6 +984,20 @@
+ }
+
+
++template<class SV, class BV>
++void convert_bv2sv(SV& sv, const BV& bv)
++{
++ typename SV::back_insert_iterator bit = sv.get_back_inserter();
++ typename BV::enumerator en = bv.first();
++ for (; en.valid(); ++en)
++ {
++ auto v = en.value();
++ bit = v;
++ }
++ bit.flush();
++}
++
++
+ } // namespace
+
+ #include "bmundef.h"
+Index: c++/include/util/bitset/bmundef.h
+===================================================================
+--- a/c++/include/util/bitset/bmundef.h (revision 90103)
++++ b/c++/include/util/bitset/bmundef.h (revision 90104)
+@@ -72,7 +72,10 @@
+
+ #undef VECT_ARR_BLOCK_LOOKUP
+ #undef VECT_SET_BLOCK_BITS
++
+ #undef VECT_BLOCK_CHANGE
++#undef VECT_BLOCK_CHANGE_BC
++
+ #undef VECT_BIT_TO_GAP
+
+ #undef VECT_AND_DIGEST
+@@ -80,7 +83,12 @@
+ #undef VECT_AND_DIGEST_5WAY
+ #undef VECT_BLOCK_SET_DIGEST
+
++#undef VECT_BLOCK_XOR_CHANGE
++#undef VECT_BIT_BLOCK_XOR
++
++#undef VECT_BIT_FIND_FIRST
+ #undef VECT_BIT_FIND_DIFF
++#undef VECT_GAP_BFIND
+
+ #undef BMI1_SELECT64
+ #undef BMI2_SELECT64
+Index: c++/include/util/bitset/bmalgo_impl.h
+===================================================================
+--- a/c++/include/util/bitset/bmalgo_impl.h (revision 90103)
++++ b/c++/include/util/bitset/bmalgo_impl.h (revision 90104)
+@@ -70,7 +70,7 @@
+ \ingroup distance
+ */
+ inline
+-distance_metric operation2metric(set_operation op)
++distance_metric operation2metric(set_operation op) BMNOEXCEPT
+ {
+ BM_ASSERT(is_const_set_operation(op));
+ if (op == set_COUNT) op = set_COUNT_B;
+@@ -95,11 +95,11 @@
+ distance_metric metric;
+ size_type result;
+
+- distance_metric_descriptor(distance_metric m)
++ distance_metric_descriptor(distance_metric m) BMNOEXCEPT
+ : metric(m),
+ result(0)
+ {}
+- distance_metric_descriptor()
++ distance_metric_descriptor() BMNOEXCEPT
+ : metric(bm::COUNT_XOR),
+ result(0)
+ {}
+@@ -107,7 +107,7 @@
+ /*!
+ \brief Sets metric result to 0
+ */
+- void reset()
++ void reset() BMNOEXCEPT
+ {
+ result = 0;
+ }
+@@ -125,7 +125,7 @@
+ void combine_count_operation_with_block(const bm::word_t* blk,
+ const bm::word_t* arg_blk,
+ distance_metric_descriptor* dmit,
+- distance_metric_descriptor* dmit_end)
++ distance_metric_descriptor* dmit_end) BMNOEXCEPT
+
+ {
+ gap_word_t* g1 = BMGAP_PTR(blk);
+@@ -340,7 +340,7 @@
+ */
+ inline
+ unsigned combine_count_and_operation_with_block(const bm::word_t* blk,
+- const bm::word_t* arg_blk)
++ const bm::word_t* arg_blk) BMNOEXCEPT
+ {
+ unsigned gap = BM_IS_GAP(blk);
+ unsigned arg_gap = BM_IS_GAP(arg_blk);
+@@ -381,7 +381,7 @@
+ const bm::word_t* arg_blk,
+ unsigned arg_gap,
+ distance_metric_descriptor* dmit,
+- distance_metric_descriptor* dmit_end)
++ distance_metric_descriptor* dmit_end) BMNOEXCEPT
+
+ {
+ gap_word_t* res=0;
+@@ -628,7 +628,7 @@
+ unsigned
+ combine_count_operation_with_block(const bm::word_t* blk,
+ const bm::word_t* arg_blk,
+- distance_metric metric)
++ distance_metric metric) BMNOEXCEPT
+ {
+ distance_metric_descriptor dmd(metric);
+ combine_count_operation_with_block(blk, //gap,
+@@ -649,7 +649,7 @@
+ unsigned gap,
+ const bm::word_t* arg_blk,
+ unsigned arg_gap,
+- distance_metric metric)
++ distance_metric metric) BMNOEXCEPT
+ {
+ distance_metric_descriptor dmd(metric);
+ combine_any_operation_with_block(blk, gap,
+@@ -668,7 +668,7 @@
+ inline
+ void distance_stage(const distance_metric_descriptor* dmit,
+ const distance_metric_descriptor* dmit_end,
+- bool* is_all_and)
++ bool* is_all_and) BMNOEXCEPT
+ {
+ for (const distance_metric_descriptor* it = dmit; it < dmit_end; ++it)
+ {
+@@ -702,7 +702,7 @@
+ void distance_operation(const BV& bv1,
+ const BV& bv2,
+ distance_metric_descriptor* dmit,
+- distance_metric_descriptor* dmit_end)
++ distance_metric_descriptor* dmit_end) BMNOEXCEPT
+ {
+ const typename BV::blocks_manager_type& bman1 = bv1.get_blocks_manager();
+ const typename BV::blocks_manager_type& bman2 = bv2.get_blocks_manager();
+@@ -787,7 +787,7 @@
+ */
+ template<class BV>
+ typename BV::size_type distance_and_operation(const BV& bv1,
+- const BV& bv2)
++ const BV& bv2) BMNOEXCEPT
+ {
+ const typename BV::blocks_manager_type& bman1 = bv1.get_blocks_manager();
+ const typename BV::blocks_manager_type& bman2 = bv2.get_blocks_manager();
+@@ -858,7 +858,7 @@
+ void distance_operation_any(const BV& bv1,
+ const BV& bv2,
+ distance_metric_descriptor* dmit,
+- distance_metric_descriptor* dmit_end)
++ distance_metric_descriptor* dmit_end) BMNOEXCEPT
+ {
+ const typename BV::blocks_manager_type& bman1 = bv1.get_blocks_manager();
+ const typename BV::blocks_manager_type& bman2 = bv2.get_blocks_manager();
+@@ -980,7 +980,8 @@
+ \internal
+ */
+ template<typename It, typename SIZE_TYPE>
+-It block_range_scan(It first, It last, SIZE_TYPE nblock, SIZE_TYPE* max_id)
++It block_range_scan(It first, It last,
++ SIZE_TYPE nblock, SIZE_TYPE* max_id) BMNOEXCEPT
+ {
+ SIZE_TYPE m = *max_id;
+ It right;
+@@ -1333,7 +1334,11 @@
+ typename BV::blocks_manager_type::block_idx_type st = 0;
+ bm::for_each_block(blk_root, bman.top_block_size(), func, st);
+
+- return func.count();
++ typename BV::size_type intervals = func.count();
++ bool last_bit_set = bv.test(bm::id_max-1);
++
++ intervals -= last_bit_set; // correct last (out of range) interval
++ return intervals;
+ }
+
+ /*!
+@@ -1514,7 +1519,7 @@
+
+
+ /*!
+- \brief for-each visitor, calls a special visitor functor for each 1 bit group
++ \brief for-each visitor, calls a visitor functor for each 1 bit group
+
+ \param block - bit block buffer pointer
+ \param offset - global block offset (number of bits)
+@@ -1527,6 +1532,7 @@
+ void for_each_bit_blk(const bm::word_t* block, SIZE_TYPE offset,
+ Func& bit_functor)
+ {
++ BM_ASSERT(block);
+ if (IS_FULL_BLOCK(block))
+ {
+ bit_functor.add_range(offset, bm::gap_max_bits);
+@@ -1547,7 +1553,111 @@
+ } while (block < block_end);
+ }
+
++/*!
++ \brief for-each range visitor, calls a visitor functor for each 1 bit group
+
++ \param block - bit block buffer pointer
++ \param offset - global block offset (number of bits)
++ \param left - bit addredd in block from [from..to]
++ \param right - bit addredd in block to [from..to]
++ \param bit_functor - functor must support .add_bits(offset, bits_ptr, size)
++
++ @ingroup bitfunc
++ @internal
++*/
++template<typename Func, typename SIZE_TYPE>
++void for_each_bit_blk(const bm::word_t* block, SIZE_TYPE offset,
++ unsigned left, unsigned right,
++ Func& bit_functor)
++{
++ BM_ASSERT(block);
++ BM_ASSERT(left <= right);
++ BM_ASSERT(right < bm::bits_in_block);
++
++ if (IS_FULL_BLOCK(block))
++ {
++ unsigned sz = right - left + 1;
++ bit_functor.add_range(offset + left, sz);
++ return;
++ }
++ unsigned char bits[bm::set_bitscan_wave_size*32];
++
++ unsigned cnt, nword, nbit, bitcount, temp;
++ nbit = left & bm::set_word_mask;
++ const bm::word_t* word =
++ block + (nword = unsigned(left >> bm::set_word_shift));
++ if (left == right) // special case (only 1 bit to check)
++ {
++ if ((*word >> nbit) & 1u)
++ {
++ bits[0] = (unsigned char)nbit;
++ bit_functor.add_bits(offset + (nword * 32), bits, 1);
++ }
++ return;
++ }
++
++ bitcount = right - left + 1u;
++ if (nbit) // starting position is not aligned
++ {
++ unsigned right_margin = nbit + right - left;
++ if (right_margin < 32)
++ {
++ unsigned mask =
++ block_set_table<true>::_right[nbit] &
++ block_set_table<true>::_left[right_margin];
++ temp = (*word & mask);
++ cnt = bm::bitscan_popcnt(temp, bits);
++ if (cnt)
++ bit_functor.add_bits(offset + (nword * 32), bits, cnt);
++
++ return;
++ }
++ temp = *word & block_set_table<true>::_right[nbit];
++ cnt = bm::bitscan_popcnt(temp, bits);
++ if (cnt)
++ bit_functor.add_bits(offset + (nword * 32), bits, cnt);
++ bitcount -= 32 - nbit;
++ ++word; ++nword;
++ }
++ else
++ {
++ bitcount = right - left + 1u;
++ }
++ BM_ASSERT(bm::set_bitscan_wave_size == 4);
++ // now when we are word aligned, we can scan the bit-stream
++ // loop unrolled to evaluate 4 words at a time
++ for ( ;bitcount >= 128;
++ bitcount-=128, word+=bm::set_bitscan_wave_size,
++ nword += bm::set_bitscan_wave_size)
++ {
++ cnt = bm::bitscan_wave(word, bits);
++ if (cnt)
++ bit_functor.add_bits(offset + (nword * 32), bits, cnt);
++ } // for
++
++ for ( ;bitcount >= 32; bitcount-=32, ++word)
++ {
++ temp = *word;
++ cnt = bm::bitscan_popcnt(temp, bits);
++ if (cnt)
++ bit_functor.add_bits(offset + (nword * 32), bits, cnt);
++ ++nword;
++ } // for
++
++ BM_ASSERT(bitcount < 32);
++
++ if (bitcount) // we have a tail to count
++ {
++ temp = *word & block_set_table<true>::_left[bitcount-1];
++ cnt = bm::bitscan_popcnt(temp, bits);
++ if (cnt)
++ bit_functor.add_bits(offset + (nword * 32), bits, cnt);
++ }
++
++}
++
++
++
+ /*!
+ \brief for-each visitor, calls a special visitor functor for each 1 bit range
+
+@@ -1577,7 +1687,224 @@
+ }
+ }
+
++/*!
++ \brief for-each visitor, calls a special visitor functor for each 1 bit range
+
++ \param buf - bit block buffer pointer
++ \param offset - global block offset (number of bits)
++ \param left - interval start [left..right]
++ \param right - intreval end [left..right]
++ \param bit_functor - functor must support .add_range(offset, bits_ptr, size)
++
++ @ingroup gapfunc
++ @internal
++*/
++template<typename T, typename Func, typename SIZE_TYPE>
++void for_each_gap_blk_range(const T* BMRESTRICT buf,
++ SIZE_TYPE offset,
++ unsigned left, unsigned right,
++ Func& bit_functor)
++{
++ BM_ASSERT(left <= right);
++ BM_ASSERT(right < bm::bits_in_block);
++
++ unsigned is_set;
++ unsigned start_pos = bm::gap_bfind(buf, left, &is_set);
++ const T* BMRESTRICT pcurr = buf + start_pos;
++
++ if (is_set)
++ {
++ if (right <= *pcurr)
++ {
++ bit_functor.add_range(offset + left, (right + 1)-left);
++ return;
++ }
++ bit_functor.add_range(offset + left, (*pcurr + 1)-left);
++ ++pcurr;
++ }
++
++ const T* BMRESTRICT pend = buf + (*buf >> 3);
++ for (++pcurr; pcurr <= pend; pcurr += 2)
++ {
++ T prev = *(pcurr-1);
++ if (right <= *pcurr)
++ {
++ int sz = int(right) - int(prev);
++ if (sz > 0)
++ bit_functor.add_range(offset + prev + 1, unsigned(sz));
++ return;
++ }
++ bit_functor.add_range(offset + prev + 1, *pcurr - prev);
++ } // for
++}
++
++
++
++/*! For each non-zero block in [from, to] executes supplied functor
++ \internal
++*/
++template<typename T, typename N, typename F>
++void for_each_bit_block_range(T*** root,
++ N top_size, N nb_from, N nb_to, F& f)
++{
++ BM_ASSERT(top_size);
++ if (nb_from > nb_to)
++ return;
++ unsigned i_from = unsigned(nb_from >> bm::set_array_shift);
++ unsigned j_from = unsigned(nb_from & bm::set_array_mask);
++ unsigned i_to = unsigned(nb_to >> bm::set_array_shift);
++ unsigned j_to = unsigned(nb_to & bm::set_array_mask);
++
++ if (i_from >= top_size)
++ return;
++ if (i_to >= top_size)
++ {
++ i_to = unsigned(top_size-1);
++ j_to = bm::set_sub_array_size-1;
++ }
++
++ for (unsigned i = i_from; i <= i_to; ++i)
++ {
++ T** blk_blk = root[i];
++ if (!blk_blk)
++ continue;
++ if ((bm::word_t*)blk_blk == FULL_BLOCK_FAKE_ADDR)
++ {
++ unsigned j = (i == i_from) ? j_from : 0;
++ if (!j && (i != i_to)) // full sub-block
++ {
++ N base_idx = bm::get_super_block_start<N>(i);
++ f.add_range(base_idx, bm::set_sub_total_bits);
++ }
++ else
++ {
++ do
++ {
++ N base_idx = bm::get_block_start<N>(i, j);
++ f.add_range(base_idx, bm::gap_max_bits);
++ if ((i == i_to) && (j == j_to))
++ return;
++ } while (++j < bm::set_sub_array_size);
++ }
++ }
++ else
++ {
++ unsigned j = (i == i_from) ? j_from : 0;
++ do
++ {
++ const T* block;
++ if (blk_blk[j])
++ {
++ N base_idx = bm::get_block_start<N>(i, j);
++ if (0 != (block = blk_blk[j]))
++ {
++ if (BM_IS_GAP(block))
++ {
++ bm::for_each_gap_blk(BMGAP_PTR(block), base_idx, f);
++ }
++ else
++ {
++ bm::for_each_bit_blk(block, base_idx, f);
++ }
++ }
++ }
++
++ if ((i == i_to) && (j == j_to))
++ return;
++ } while (++j < bm::set_sub_array_size);
++ }
++ } // for i
++}
++
++
++/**
++ Implementation of for_each_bit_range without boilerplave checks
++ @internal
++*/
++template<class BV, class Func>
++void for_each_bit_range_no_check(const BV& bv,
++ typename BV::size_type left,
++ typename BV::size_type right,
++ Func& bit_functor)
++{
++ typedef typename BV::size_type size_type;
++ typedef typename BV::block_idx_type block_idx_type;
++
++ const typename BV::blocks_manager_type& bman = bv.get_blocks_manager();
++ bm::word_t*** blk_root = bman.top_blocks_root();
++ if (!blk_root)
++ return;
++
++ block_idx_type nblock_left = (left >> bm::set_block_shift);
++ block_idx_type nblock_right = (right >> bm::set_block_shift);
++
++ unsigned i0, j0;
++ bm::get_block_coord(nblock_left, i0, j0);
++ const bm::word_t* block = bman.get_block_ptr(i0, j0);
++ unsigned nbit_left = unsigned(left & bm::set_block_mask);
++ size_type offset = nblock_left * bm::bits_in_block;
++
++ if (nblock_left == nblock_right) // hit in the same block
++ {
++ if (!block)
++ return;
++ unsigned nbit_right = unsigned(right & bm::set_block_mask);
++ if (BM_IS_GAP(block))
++ {
++ bm::for_each_gap_blk_range(BMGAP_PTR(block), offset,
++ nbit_left, nbit_right, bit_functor);
++ }
++ else
++ {
++ bm::for_each_bit_blk(block, offset, nbit_left, nbit_right,
++ bit_functor);
++ }
++ return;
++ }
++ // process left block
++ if (nbit_left && block)
++ {
++ if (BM_IS_GAP(block))
++ {
++ bm::for_each_gap_blk_range(BMGAP_PTR(block), offset,
++ nbit_left, bm::bits_in_block-1, bit_functor);
++ }
++ else
++ {
++ bm::for_each_bit_blk(block, offset, nbit_left, bm::bits_in_block-1,
++ bit_functor);
++ }
++ ++nblock_left;
++ }
++
++ // process all complete blocks in the middle
++ {
++ block_idx_type top_blocks_size = bman.top_block_size();
++ bm::for_each_bit_block_range(blk_root, top_blocks_size,
++ nblock_left, nblock_right-1, bit_functor);
++ }
++
++ unsigned nbit_right = unsigned(right & bm::set_block_mask);
++ bm::get_block_coord(nblock_right, i0, j0);
++ block = bman.get_block_ptr(i0, j0);
++
++ if (block)
++ {
++ offset = nblock_right * bm::bits_in_block;
++ if (BM_IS_GAP(block))
++ {
++ bm::for_each_gap_blk_range(BMGAP_PTR(block), offset,
++ 0, nbit_right, bit_functor);
++ }
++ else
++ {
++ bm::for_each_bit_blk(block, offset, 0, nbit_right, bit_functor);
++ }
++ }
++}
++
++
++
+ } // namespace bm
+
+ #ifdef _MSC_VER
+Index: c++/include/util/bitset/bmbmatrix.h
+===================================================================
+--- a/c++/include/util/bitset/bmbmatrix.h (revision 90103)
++++ b/c++/include/util/bitset/bmbmatrix.h (revision 90104)
+@@ -72,7 +72,7 @@
+ allocation_policy_type ap = allocation_policy_type(),
+ size_type bv_max_size = bm::id_max,
+ const allocator_type& alloc = allocator_type());
+- ~basic_bmatrix() BMNOEXEPT;
++ ~basic_bmatrix() BMNOEXCEPT;
+
+ /*! copy-ctor */
+ basic_bmatrix(const basic_bmatrix<BV>& bbm);
+@@ -84,10 +84,10 @@
+
+ #ifndef BM_NO_CXX11
+ /*! move-ctor */
+- basic_bmatrix(basic_bmatrix<BV>&& bbm) BMNOEXEPT;
++ basic_bmatrix(basic_bmatrix<BV>&& bbm) BMNOEXCEPT;
+
+ /*! move assignmment operator */
+- basic_bmatrix<BV>& operator = (basic_bmatrix<BV>&& bbm) BMNOEXEPT
++ basic_bmatrix<BV>& operator = (basic_bmatrix<BV>&& bbm) BMNOEXCEPT
+ {
+ if (this != &bbm)
+ {
+@@ -98,7 +98,8 @@
+ }
+ #endif
+
+- void set_allocator_pool(allocator_pool_type* pool_ptr) { pool_ = pool_ptr; }
++ void set_allocator_pool(allocator_pool_type* pool_ptr) BMNOEXCEPT
++ { pool_ = pool_ptr; }
+
+ ///@}
+
+@@ -107,7 +108,7 @@
+ ///@{
+
+ /*! Swap content */
+- void swap(basic_bmatrix<BV>& bbm) BMNOEXEPT;
++ void swap(basic_bmatrix<BV>& bbm) BMNOEXCEPT;
+
+ /*! Copy content */
+ void copy_from(const basic_bmatrix<BV>& bbm);
+@@ -118,17 +119,17 @@
+ /*! @name row access */
+ ///@{
+
+- /*! Get row bit-vector */
+- const bvector_type* row(size_type i) const;
++ /*! Get row bit-vector. Can return NULL */
++ const bvector_type* row(size_type i) const BMNOEXCEPT;
+
+- /*! Get row bit-vector */
+- bvector_type_const_ptr get_row(size_type i) const;
++ /*! Get row bit-vector. Can return NULL */
++ bvector_type_const_ptr get_row(size_type i) const BMNOEXCEPT;
+
+- /*! Get row bit-vector */
+- bvector_type* get_row(size_type i);
++ /*! Get row bit-vector. Can return NULL */
++ bvector_type* get_row(size_type i) BMNOEXCEPT;
+
+ /*! get number of value rows */
+- size_type rows() const { return rsize_; }
++ size_type rows() const BMNOEXCEPT { return rsize_; }
+
+ /*! Make sure row is constructed, return bit-vector */
+ bvector_type_ptr construct_row(size_type row);
+@@ -168,7 +169,7 @@
+ @param pos - column position in the matrix
+ @param octet_idx - octet based row position (1 octet - 8 rows)
+ */
+- unsigned char get_octet(size_type pos, size_type octet_idx) const;
++ unsigned char get_octet(size_type pos, size_type octet_idx) const BMNOEXCEPT;
+
+ /*!
+ Compare vector[pos] with octet
+@@ -183,7 +184,7 @@
+ @return 0 - equal, -1 - less(vect[pos] < octet), 1 - greater
+ */
+ int compare_octet(size_type pos,
+- size_type octet_idx, char octet) const;
++ size_type octet_idx, char octet) const BMNOEXCEPT;
+
+ ///@}
+
+@@ -194,12 +195,13 @@
+ ///@{
+
+ /// Test if 4 rows from i are not NULL
+- bool test_4rows(unsigned i) const;
++ bool test_4rows(unsigned i) const BMNOEXCEPT;
+
+ /// Get low level internal access to
+- const bm::word_t* get_block(size_type p, unsigned i, unsigned j) const;
++ const bm::word_t* get_block(size_type p,
++ unsigned i, unsigned j) const BMNOEXCEPT;
+
+- unsigned get_half_octet(size_type pos, size_type row_idx) const;
++ unsigned get_half_octet(size_type pos, size_type row_idx) const BMNOEXCEPT;
+
+ /*!
+ \brief run memory optimization for all bit-vector rows
+@@ -222,7 +224,7 @@
+
+ protected:
+ void allocate_rows(size_type rsize);
+- void free_rows() BMNOEXEPT;
++ void free_rows() BMNOEXCEPT;
+
+ bvector_type* construct_bvector(const bvector_type* bv) const;
+ void destruct_bvector(bvector_type* bv) const;
+@@ -286,7 +288,7 @@
+
+ #ifndef BM_NO_CXX11
+ /*! move-ctor */
+- base_sparse_vector(base_sparse_vector<Val, BV, MAX_SIZE>&& bsv) BMNOEXEPT
++ base_sparse_vector(base_sparse_vector<Val, BV, MAX_SIZE>&& bsv) BMNOEXCEPT
+ {
+ bmatr_.swap(bsv.bmatr_);
+ size_ = bsv.size_;
+@@ -295,9 +297,9 @@
+ }
+ #endif
+
+- void swap(base_sparse_vector<Val, BV, MAX_SIZE>& bsv) BMNOEXEPT;
++ void swap(base_sparse_vector<Val, BV, MAX_SIZE>& bsv) BMNOEXCEPT;
+
+- size_type size() const { return size_; }
++ size_type size() const BMNOEXCEPT { return size_; }
+
+ void resize(size_type new_size);
+
+@@ -304,10 +306,10 @@
+ void clear_range(size_type left, size_type right, bool set_null);
+
+ /*! \brief resize to zero, free memory */
+- void clear() BMNOEXEPT;
++ void clear() BMNOEXCEPT;
+
+ /*! return true if empty */
+- bool empty() const { return size() == 0; }
++ bool empty() const BMNOEXCEPT { return size() == 0; }
+
+ public:
+
+@@ -317,13 +319,14 @@
+ /**
+ \brief check if container supports NULL(unassigned) values
+ */
+- bool is_nullable() const { return bmatr_.get_row(this->null_plain()) != 0; }
++ bool is_nullable() const BMNOEXCEPT
++ { return bmatr_.get_row(this->null_plain()) != 0; }
+
+ /**
+ \brief Get bit-vector of assigned values or NULL
+ (if not constructed that way)
+ */
+- const bvector_type* get_null_bvector() const
++ const bvector_type* get_null_bvector() const BMNOEXCEPT
+ { return bmatr_.get_row(this->null_plain()); }
+
+ /** \brief test if specified element is NULL
+@@ -331,7 +334,7 @@
+ \return true if it is NULL false if it was assigned or container
+ is not configured to support assignment flags
+ */
+- bool is_null(size_type idx) const;
++ bool is_null(size_type idx) const BMNOEXCEPT;
+
+
+ ///@}
+@@ -352,25 +355,27 @@
+ \return bit-vector for the bit plain or NULL
+ */
+ bvector_type_const_ptr
+- get_plain(unsigned i) const { return bmatr_.row(i); }
++ get_plain(unsigned i) const BMNOEXCEPT { return bmatr_.row(i); }
+
+ /*!
+ \brief get total number of bit-plains in the vector
+ */
+- static unsigned plains() { return value_bits(); }
++ static unsigned plains() BMNOEXCEPT { return value_bits(); }
+
+ /** Number of stored bit-plains (value plains + extra */
+- static unsigned stored_plains() { return value_bits()+1; }
++ static unsigned stored_plains() BMNOEXCEPT { return value_bits()+1; }
+
+
+ /** Number of effective bit-plains in the value type */
+- unsigned effective_plains() const { return effective_plains_ + 1; }
++ unsigned effective_plains() const BMNOEXCEPT
++ { return effective_plains_ + 1; }
+
+ /*!
+ \brief get access to bit-plain as is (can return NULL)
+ */
+- bvector_type_ptr plain(unsigned i) { return bmatr_.get_row(i); }
+- const bvector_type_ptr plain(unsigned i) const { return bmatr_.get_row(i); }
++ bvector_type_ptr plain(unsigned i) BMNOEXCEPT { return bmatr_.get_row(i); }
++ bvector_type_const_ptr plain(unsigned i) const BMNOEXCEPT
++ { return bmatr_.get_row(i); }
+
+ bvector_type* get_null_bvect() { return bmatr_.get_row(this->null_plain());}
+
+@@ -388,12 +393,12 @@
+ @return 64-bit mask
+ @internal
+ */
+- bm::id64_t get_plains_mask(unsigned element_idx) const;
++ bm::id64_t get_plains_mask(unsigned element_idx) const BMNOEXCEPT;
+
+ /*!
+ get read-only access to inetrnal bit-matrix
+ */
+- const bmatrix_type& get_bmatrix() const { return bmatr_; }
++ const bmatrix_type& get_bmatrix() const BMNOEXCEPT { return bmatr_; }
+ ///@}
+
+ /*!
+@@ -417,7 +422,7 @@
+
+ @sa statistics
+ */
+- void calc_stat(typename bvector_type::statistics* st) const;
++ void calc_stat(typename bvector_type::statistics* st) const BMNOEXCEPT;
+
+ /*!
+ \brief check if another sparse vector has the same content and size
+@@ -429,7 +434,7 @@
+ \return true, if it is the same
+ */
+ bool equal(const base_sparse_vector<Val, BV, MAX_SIZE>& sv,
+- bm::null_support null_able = bm::use_null) const;
++ bm::null_support null_able = bm::use_null) const BMNOEXCEPT;
+
+ protected:
+ void copy_from(const base_sparse_vector<Val, BV, MAX_SIZE>& bsv);
+@@ -463,13 +468,13 @@
+ typedef typename bvector_type::block_idx_type block_idx_type;
+
+ /** Number of total bit-plains in the value type*/
+- static unsigned value_bits()
++ static unsigned value_bits() BMNOEXCEPT
+ {
+ return base_sparse_vector<Val, BV, MAX_SIZE>::sv_value_plains;
+ }
+
+ /** plain index for the "NOT NULL" flags plain */
+- static unsigned null_plain() { return value_bits(); }
++ static unsigned null_plain() BMNOEXCEPT { return value_bits(); }
+
+ /** optimize block in all matrix plains */
+ void optimize_block(block_idx_type nb)
+@@ -515,7 +520,7 @@
+ //---------------------------------------------------------------------
+
+ template<typename BV>
+-basic_bmatrix<BV>::~basic_bmatrix() BMNOEXEPT
++basic_bmatrix<BV>::~basic_bmatrix() BMNOEXCEPT
+ {
+ free_rows();
+ }
+@@ -537,7 +542,7 @@
+ //---------------------------------------------------------------------
+
+ template<typename BV>
+-basic_bmatrix<BV>::basic_bmatrix(basic_bmatrix<BV>&& bbm) BMNOEXEPT
++basic_bmatrix<BV>::basic_bmatrix(basic_bmatrix<BV>&& bbm) BMNOEXCEPT
+ : bv_size_(bbm.bv_size_),
+ alloc_(bbm.alloc_),
+ ap_(bbm.ap_),
+@@ -552,7 +557,7 @@
+
+ template<typename BV>
+ const typename basic_bmatrix<BV>::bvector_type*
+-basic_bmatrix<BV>::row(size_type i) const
++basic_bmatrix<BV>::row(size_type i) const BMNOEXCEPT
+ {
+ BM_ASSERT(i < rsize_);
+ return bv_rows_[i];
+@@ -562,7 +567,7 @@
+
+ template<typename BV>
+ const typename basic_bmatrix<BV>::bvector_type*
+-basic_bmatrix<BV>::get_row(size_type i) const
++basic_bmatrix<BV>::get_row(size_type i) const BMNOEXCEPT
+ {
+ BM_ASSERT(i < rsize_);
+ return bv_rows_[i];
+@@ -572,7 +577,7 @@
+
+ template<typename BV>
+ typename basic_bmatrix<BV>::bvector_type*
+-basic_bmatrix<BV>::get_row(size_type i)
++basic_bmatrix<BV>::get_row(size_type i) BMNOEXCEPT
+ {
+ BM_ASSERT(i < rsize_);
+ return bv_rows_[i];
+@@ -581,7 +586,7 @@
+ //---------------------------------------------------------------------
+
+ template<typename BV>
+-bool basic_bmatrix<BV>::test_4rows(unsigned j) const
++bool basic_bmatrix<BV>::test_4rows(unsigned j) const BMNOEXCEPT
+ {
+ BM_ASSERT((j + 4) <= rsize_);
+ #if defined(BM64_SSE4)
+@@ -593,7 +598,8 @@
+ __m256i w0 = _mm256_loadu_si256((__m256i*)(bv_rows_ + j));
+ return !_mm256_testz_si256(w0, w0);
+ #else
+- bool b = bv_rows_[j + 0] || bv_rows_[j + 1] || bv_rows_[j + 2] || bv_rows_[j + 3];
++ bool b = bv_rows_[j + 0] || bv_rows_[j + 1] ||
++ bv_rows_[j + 2] || bv_rows_[j + 3];
+ return b;
+ #endif
+ }
+@@ -655,7 +661,7 @@
+ //---------------------------------------------------------------------
+
+ template<typename BV>
+-void basic_bmatrix<BV>::free_rows() BMNOEXEPT
++void basic_bmatrix<BV>::free_rows() BMNOEXCEPT
+ {
+ for (size_type i = 0; i < rsize_; ++i)
+ {
+@@ -676,7 +682,7 @@
+ //---------------------------------------------------------------------
+
+ template<typename BV>
+-void basic_bmatrix<BV>::swap(basic_bmatrix<BV>& bbm) BMNOEXEPT
++void basic_bmatrix<BV>::swap(basic_bmatrix<BV>& bbm) BMNOEXCEPT
+ {
+ if (this == &bbm)
+ return;
+@@ -795,12 +801,14 @@
+
+ template<typename BV>
+ const bm::word_t*
+-basic_bmatrix<BV>::get_block(size_type p, unsigned i, unsigned j) const
++basic_bmatrix<BV>::get_block(size_type p,
++ unsigned i, unsigned j) const BMNOEXCEPT
+ {
+ bvector_type_const_ptr bv = this->row(p);
+ if (bv)
+ {
+- const typename bvector_type::blocks_manager_type& bman = bv->get_blocks_manager();
++ const typename bvector_type::blocks_manager_type& bman =
++ bv->get_blocks_manager();
+ return bman.get_block_ptr(i, j);
+ }
+ return 0;
+@@ -902,7 +910,7 @@
+
+ template<typename BV>
+ unsigned char
+-basic_bmatrix<BV>::get_octet(size_type pos, size_type octet_idx) const
++basic_bmatrix<BV>::get_octet(size_type pos, size_type octet_idx) const BMNOEXCEPT
+ {
+ unsigned v = 0;
+
+@@ -1003,7 +1011,7 @@
+ template<typename BV>
+ int basic_bmatrix<BV>::compare_octet(size_type pos,
+ size_type octet_idx,
+- char octet) const
++ char octet) const BMNOEXCEPT
+ {
+ char value = char(get_octet(pos, octet_idx));
+ return (value > octet) - (value < octet);
+@@ -1013,7 +1021,7 @@
+
+ template<typename BV>
+ unsigned
+-basic_bmatrix<BV>::get_half_octet(size_type pos, size_type row_idx) const
++basic_bmatrix<BV>::get_half_octet(size_type pos, size_type row_idx) const BMNOEXCEPT
+ {
+ unsigned v = 0;
+
+@@ -1198,7 +1206,7 @@
+
+ template<class Val, class BV, unsigned MAX_SIZE>
+ void base_sparse_vector<Val, BV, MAX_SIZE>::swap(
+- base_sparse_vector<Val, BV, MAX_SIZE>& bsv) BMNOEXEPT
++ base_sparse_vector<Val, BV, MAX_SIZE>& bsv) BMNOEXCEPT
+ {
+ if (this != &bsv)
+ {
+@@ -1212,7 +1220,7 @@
+ //---------------------------------------------------------------------
+
+ template<class Val, class BV, unsigned MAX_SIZE>
+-void base_sparse_vector<Val, BV, MAX_SIZE>::clear() BMNOEXEPT
++void base_sparse_vector<Val, BV, MAX_SIZE>::clear() BMNOEXCEPT
+ {
+ unsigned plains = value_bits();
+ for (size_type i = 0; i < plains; ++i)
+@@ -1274,7 +1282,8 @@
+ //---------------------------------------------------------------------
+
+ template<class Val, class BV, unsigned MAX_SIZE>
+-bool base_sparse_vector<Val, BV, MAX_SIZE>::is_null(size_type idx) const
++bool base_sparse_vector<Val, BV, MAX_SIZE>::is_null(
++ size_type idx) const BMNOEXCEPT
+ {
+ const bvector_type* bv_null = get_null_bvector();
+ return (bv_null) ? (!bv_null->test(idx)) : false;
+@@ -1312,7 +1321,7 @@
+
+ template<class Val, class BV, unsigned MAX_SIZE>
+ bm::id64_t base_sparse_vector<Val, BV, MAX_SIZE>::get_plains_mask(
+- unsigned element_idx) const
++ unsigned element_idx) const BMNOEXCEPT
+ {
+ BM_ASSERT(element_idx < MAX_SIZE);
+ bm::id64_t mask = 0;
+@@ -1364,7 +1373,7 @@
+
+ template<class Val, class BV, unsigned MAX_SIZE>
+ void base_sparse_vector<Val, BV, MAX_SIZE>::calc_stat(
+- typename bvector_type::statistics* st) const
++ typename bvector_type::statistics* st) const BMNOEXCEPT
+ {
+ BM_ASSERT(st);
+
+@@ -1409,7 +1418,7 @@
+
+ template<class Val, class BV, unsigned MAX_SIZE>
+ void base_sparse_vector<Val, BV, MAX_SIZE>::insert_clear_value_plains_from(
+- unsigned plain_idx, size_type idx)
++ unsigned plain_idx, size_type idx)
+ {
+ for (unsigned i = plain_idx; i < sv_value_plains; ++i)
+ {
+@@ -1437,7 +1446,7 @@
+ template<class Val, class BV, unsigned MAX_SIZE>
+ bool base_sparse_vector<Val, BV, MAX_SIZE>::equal(
+ const base_sparse_vector<Val, BV, MAX_SIZE>& sv,
+- bm::null_support null_able) const
++ bm::null_support null_able) const BMNOEXCEPT
+ {
+ size_type arg_size = sv.size();
+ if (this->size_ != arg_size)
+@@ -1468,11 +1477,6 @@
+ bool eq = bv->equal(*arg_bv);
+ if (!eq)
+ return false;
+- /*
+- int cmp = bv->compare(*arg_bv);
+- if (cmp != 0)
+- return false;
+- */
+ } // for j
+
+ if (null_able == bm::use_null)
+@@ -1490,11 +1494,6 @@
+ bool eq = bv_null->equal(*bv_null_arg);
+ if (!eq)
+ return false;
+- /*
+- int cmp = bv_null->compare(*bv_null);
+- if (cmp != 0)
+- return false;
+- */
+ }
+ return true;
+ }
+Index: c++/include/util/bitset/bmintervals.h
+===================================================================
+--- a/c++/include/util/bitset/bmintervals.h (nonexistent)
++++ b/c++/include/util/bitset/bmintervals.h (revision 90104)
+@@ -0,0 +1,781 @@
++#ifndef BMINTERVALS__H__INCLUDED__
++#define BMINTERVALS__H__INCLUDED__
++
++/*
++Copyright(c) 2002-2020 Anatoliy Kuznetsov(anatoliy_kuznetsov at yahoo.com)
++
++Licensed under the Apache License, Version 2.0 (the "License");
++you may not use this file except in compliance with the License.
++You may obtain a copy of the License at
++
++ http://www.apache.org/licenses/LICENSE-2.0
++
++Unless required by applicable law or agreed to in writing, software
++distributed under the License is distributed on an "AS IS" BASIS,
++WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++See the License for the specific language governing permissions and
++limitations under the License.
++
++For more information please visit: http://bitmagic.io
++*/
++/*! \file bmintervals.h
++ \brief Algorithms for bit ranges and intervals
++*/
++
++#ifndef BM__H__INCLUDED__
++// BitMagic utility headers do not include main "bm.h" declaration
++// #include "bm.h" or "bm64.h" explicitly
++# error missing include (bm.h or bm64.h)
++#endif
++
++#include "bmdef.h"
++
++/** \defgroup bvintervals Algorithms for bit intervals
++ Algorithms and iterators for bit ranges and intervals
++ @ingroup bvector
++ */
++
++
++namespace bm
++{
++
++/*!
++ \brief forward iterator class to traverse bit-vector as ranges
++
++ Traverse enumerator for forward walking bit-vector as intervals:
++ series of consequtive 1111s flanked with zeroes.
++ Enumerator can traverse the whole bit-vector or jump(go_to) to position.
++
++ \ingroup bvintervals
++*/
++template<typename BV>
++class interval_enumerator
++{
++public:
++#ifndef BM_NO_STL
++ typedef std::input_iterator_tag iterator_category;
++#endif
++ typedef BV bvector_type;
++ typedef typename bvector_type::size_type size_type;
++ typedef typename bvector_type::allocator_type allocator_type;
++ typedef bm::byte_buffer<allocator_type> buffer_type;
++ typedef bm::pair<size_type, size_type> pair_type;
++
++public:
++ /*! @name Construction and assignment */
++ //@{
++
++ interval_enumerator()
++ : bv_(0), interval_(bm::id_max, bm::id_max), gap_ptr_(0)
++ {}
++
++ /**
++ Construct enumerator for the bit-vector
++ */
++ interval_enumerator(const BV& bv)
++ : bv_(&bv), interval_(bm::id_max, bm::id_max), gap_ptr_(0)
++ {
++ go_to_impl(0, false);
++ }
++
++ /**
++ Construct enumerator for the specified position
++ @param bv - source bit-vector
++ @param start_pos - position on bit-vector to search for interval
++ @param extend_start - flag to extend interval start to the start if
++ true start happenes to be less than start_pos
++ @sa go_to
++ */
++ interval_enumerator(const BV& bv, size_type start_pos, bool extend_start)
++ : bv_(&bv), interval_(bm::id_max, bm::id_max), gap_ptr_(0)
++ {
++ go_to_impl(start_pos, extend_start);
++ }
++
++ /**
++ Copy constructor
++ */
++ interval_enumerator(const interval_enumerator<BV>& ien)
++ : bv_(ien.bv_), interval_(bm::id_max, bm::id_max), gap_ptr_(0)
++ {
++ go_to_impl(ien.start(), false);
++ }
++
++ /**
++ Assignment operator
++ */
++ interval_enumerator& operator=(const interval_enumerator<BV>& ien)
++ {
++ bv_ = ien.bv_; gap_ptr_ = 0;
++ go_to_impl(ien.start(), false);
++ }
++
++#ifndef BM_NO_CXX11
++ /** move-ctor */
++ interval_enumerator(interval_enumerator<BV>&& ien) BMNOEXCEPT
++ : bv_(0), interval_(bm::id_max, bm::id_max), gap_ptr_(0)
++ {
++ this->swap(ien);
++ }
++
++ /** move assignmment operator */
++ interval_enumerator<BV>& operator=(interval_enumerator<BV>&& ien) BMNOEXCEPT
++ {
++ if (this != &ien)
++ this->swap(ien);
++ return *this;
++ }
++#endif
++
++ //@}
++
++
++ // -----------------------------------------------------------------
++
++ /*! @name Comparison methods all use start position to compare */
++ //@{
++
++ bool operator==(const interval_enumerator<BV>& ien) const BMNOEXCEPT
++ { return (start() == ien.start()); }
++ bool operator!=(const interval_enumerator<BV>& ien) const BMNOEXCEPT
++ { return (start() != ien.start()); }
++ bool operator < (const interval_enumerator<BV>& ien) const BMNOEXCEPT
++ { return (start() < ien.start()); }
++ bool operator <= (const interval_enumerator<BV>& ien) const BMNOEXCEPT
++ { return (start() <= ien.start()); }
++ bool operator > (const interval_enumerator<BV>& ien) const BMNOEXCEPT
++ { return (start() > ien.start()); }
++ bool operator >= (const interval_enumerator<BV>& ien) const BMNOEXCEPT
++ { return (start() >= ien.start()); }
++ //@}
++
++
++ /// Return interval start/left as bit-vector coordinate 011110 [left..right]
++ size_type start() const BMNOEXCEPT;
++ /// Return interval end/right as bit-vector coordinate 011110 [left..right]
++ size_type end() const BMNOEXCEPT;
++
++ const pair_type& operator*() const BMNOEXCEPT { return interval_; }
++
++ /// Get interval pair
++ const pair_type& get() const BMNOEXCEPT { return interval_; }
++
++ /// Returns true if enumerator is valid (false if traversal is done)
++ bool valid() const BMNOEXCEPT;
++
++ // -----------------------------------------------------------------
++
++ /*! @name enumerator positioning */
++ //@{
++
++ /*!
++ @brief Go to inetrval at specified position
++ Jump to position with interval. If interval is not available at
++ the specified position (o bit) enumerator will find the next interval.
++ If interval is present we have an option to find interval start [left..]
++ and set enumerator from the effective start coodrinate
++
++ @param pos - position on bit-vector
++ @param extend_start - find effective start if it is less than the
++ go to position
++ @return true if enumerator remains valid after the jump
++ */
++ bool go_to(size_type pos, bool extend_start = true);
++
++ /*! Advance to the next interval
++ @return true if interval is available
++ @sa valid
++ */
++ bool advance();
++
++ /*! \brief Advance enumerator forward to the next available bit */
++ interval_enumerator<BV>& operator++() BMNOEXCEPT
++ { advance(); return *this; }
++
++ /*! \brief Advance enumerator forward to the next available bit */
++ interval_enumerator<BV> operator++(int) BMNOEXCEPT
++ {
++ interval_enumerator<BV> tmp = *this;
++ advance();
++ return tmp;
++ }
++ //@}
++
++ /**
++ swap enumerator with another one
++ */
++ void swap(interval_enumerator<BV>& ien) BMNOEXCEPT;
++
++protected:
++ typedef typename bvector_type::block_idx_type block_idx_type;
++ typedef typename bvector_type::allocator_type bv_allocator_type;
++ typedef bm::heap_vector<unsigned short, bv_allocator_type, true>
++ gap_vector_type;
++
++
++ bool go_to_impl(size_type pos, bool extend_start);
++
++ /// Turn FSM into invalid state (out of range)
++ void invalidate() BMNOEXCEPT;
++
++private:
++ const BV* bv_; ///!< bit-vector for traversal
++ gap_vector_type gap_buf_; ///!< GAP buf.vector for bit-block
++ pair_type interval_; ///! current inetrval
++ const bm::gap_word_t* gap_ptr_; ///!< current pointer in GAP block
++};
++
++//----------------------------------------------------------------------------
++
++/*!
++ \brief Returns true if range is all 1s flanked with 0s
++ Function performs the test on a closed range [left, right]
++ true interval is all 1s AND test(left-1)==false AND test(right+1)==false
++ Examples:
++ 01110 [1,3] - true
++ 11110 [0,3] - true
++ 11110 [1,3] - false
++ \param bv - bit-vector for check
++ \param left - index of first bit start checking
++ \param right - index of last bit
++ \return true/false
++
++ \ingroup bvintervals
++
++ @sa is_all_one_range
++*/
++template<class BV>
++bool is_interval(const BV& bv,
++ typename BV::size_type left,
++ typename BV::size_type right) BMNOEXCEPT
++{
++ typedef typename BV::block_idx_type block_idx_type;
++
++ const typename BV::blocks_manager_type& bman = bv.get_blocks_manager();
++
++ if (!bman.is_init())
++ return false; // nothing to do
++
++ if (right < left)
++ bm::xor_swap(left, right);
++ if (left == bm::id_max) // out of range
++ return false;
++ if (right == bm::id_max)
++ --right;
++
++ block_idx_type nblock_left = (left >> bm::set_block_shift);
++ block_idx_type nblock_right = (right >> bm::set_block_shift);
++
++ if (nblock_left == nblock_right) // same block (fast case)
++ {
++ unsigned nbit_left = unsigned(left & bm::set_block_mask);
++ unsigned nbit_right = unsigned(right & bm::set_block_mask);
++ if ((nbit_left > 0) && (nbit_right < bm::gap_max_bits-1))
++ {
++ unsigned i0, j0;
++ bm::get_block_coord(nblock_left, i0, j0);
++ const bm::word_t* block = bman.get_block_ptr(i0, j0);
++ bool b = bm::block_is_interval(block, nbit_left, nbit_right);
++ return b;
++ }
++ }
++ bool is_left, is_right, is_all_one;
++ is_left = left > 0 ? bv.test(left-1) : false;
++ if (is_left == false)
++ {
++ is_right = (right < (bm::id_max - 1)) ? bv.test(right + 1) : false;
++ if (is_left == false && is_right == false)
++ {
++ is_all_one = bv.is_all_one_range(left, right);
++ return is_all_one;
++ }
++ }
++ return false;
++}
++
++
++//----------------------------------------------------------------------------
++
++/*!
++
++ \brief Reverse find index of first 1 bit gap (01110) starting from position
++ Reverse scan for the first 1 in a block of continious 1s.
++ Method employs closed interval semantics: 0[pos..from]
++
++ \param bv - bit-vector for search
++ \param from - position to start reverse search from
++ \param pos - [out] index of the found first 1 bit in a gap of bits
++ \return true if search returned result, false if not found
++ (start point is zero)
++
++ \sa is_interval, find_interval_end
++ \ingroup bvintervals
++*/
++template<class BV>
++bool find_interval_start(const BV& bv,
++ typename BV::size_type from,
++ typename BV::size_type& pos) BMNOEXCEPT
++{
++ typedef typename BV::size_type size_type;
++ typedef typename BV::block_idx_type block_idx_type;
++
++ const typename BV::blocks_manager_type& bman = bv.get_blocks_manager();
++
++ if (!bman.is_init())
++ return false; // nothing to do
++ if (!from)
++ {
++ pos = from;
++ return bv.test(from);
++ }
++
++ block_idx_type nb = (from >> bm::set_block_shift);
++ unsigned i0, j0;
++ bm::get_block_coord(nb, i0, j0);
++
++ size_type base_idx;
++ unsigned found_nbit;
++
++ const bm::word_t* block = bman.get_block_ptr(i0, j0);
++ if (!block)
++ return false;
++ unsigned nbit = unsigned(from & bm::set_block_mask);
++ unsigned res = bm::block_find_interval_start(block, nbit, &found_nbit);
++
++ switch (res)
++ {
++ case 0: // not interval
++ return false;
++ case 1: // interval found
++ pos = found_nbit + (nb * bm::gap_max_bits);
++ return true;
++ case 2: // keep scanning
++ base_idx = bm::get_block_start<size_type>(i0, j0);
++ pos = base_idx + found_nbit;
++ if (!nb)
++ return true;
++ break;
++ default:
++ BM_ASSERT(0);
++ } // switch
++
++ --nb;
++ bm::get_block_coord(nb, i0, j0);
++ bm::word_t*** blk_root = bman.top_blocks_root();
++
++ for (unsigned i = i0; true; --i)
++ {
++ bm::word_t** blk_blk = blk_root[i];
++ if (!blk_blk)
++ return true;
++ if ((bm::word_t*)blk_blk == FULL_BLOCK_FAKE_ADDR)
++ {
++ pos = bm::get_super_block_start<size_type>(i);
++ if (!i)
++ break;
++ continue;
++ }
++ unsigned j = (i == i0) ? j0 : 255;
++ for (; true; --j)
++ {
++ if ((bm::word_t*)blk_blk == FULL_BLOCK_FAKE_ADDR)
++ {
++ pos = bm::get_block_start<size_type>(i, j);
++ goto loop_j_end; // continue
++ }
++
++ block = blk_blk[j];
++ if (!block)
++ return true;
++
++ res = bm::block_find_interval_start(block,
++ bm::gap_max_bits-1, &found_nbit);
++ switch (res)
++ {
++ case 0: // not interval (but it was the interval, so last result
++ return true;
++ case 1: // interval found
++ base_idx = bm::get_block_start<size_type>(i, j);
++ pos = base_idx + found_nbit;
++ return true;
++ case 2: // keep scanning
++ pos = bm::get_block_start<size_type>(i, j);
++ break;
++ default:
++ BM_ASSERT(0);
++ } // switch
++
++ loop_j_end: // continue point
++ if (!j)
++ break;
++ } // for j
++
++ if (!i)
++ break;
++ } // for i
++
++ return true;
++}
++
++
++//----------------------------------------------------------------------------
++
++/*!
++ \brief Reverse find index of first 1 bit gap (01110) starting from position
++ Reverse scan for the first 1 in a block of continious 1s.
++ Method employs closed interval semantics: 0[pos..from]
++
++ \param bv - bit-vector for search
++ \param from - position to start reverse search from
++ \param pos - [out] index of the found first 1 bit in a gap of bits
++ \return true if search returned result, false if not found
++ (start point is zero)
++
++ \sa is_interval, find_interval_end
++ \ingroup bvintervals
++*/
++template <typename BV>
++bool find_interval_end(const BV& bv,
++ typename BV::size_type from,
++ typename BV::size_type & pos) BMNOEXCEPT
++{
++ typedef typename BV::block_idx_type block_idx_type;
++
++ if (from == bm::id_max)
++ return false;
++ const typename BV::blocks_manager_type& bman = bv.get_blocks_manager();
++
++ if (!bman.is_init())
++ return false; // nothing to do
++ if (from == bm::id_max-1)
++ {
++ pos = from;
++ return bv.test(from);
++ }
++
++ block_idx_type nb = (from >> bm::set_block_shift);
++ unsigned i0, j0;
++ bm::get_block_coord(nb, i0, j0);
++
++ unsigned found_nbit;
++
++ const bm::word_t* block = bman.get_block_ptr(i0, j0);
++ if (!block)
++ return false;
++ unsigned nbit = unsigned(from & bm::set_block_mask);
++ unsigned res = bm::block_find_interval_end(block, nbit, &found_nbit);
++ switch (res)
++ {
++ case 0: // not interval
++ return false;
++ case 1: // interval found
++ pos = found_nbit + (nb * bm::gap_max_bits);
++ return true;
++ case 2: // keep scanning
++ pos = found_nbit + (nb * bm::gap_max_bits);
++ break;
++ default:
++ BM_ASSERT(0);
++ } // switch
++
++ block_idx_type nblock_right = (bm::id_max >> bm::set_block_shift);
++ unsigned i_from, j_from, i_to, j_to;
++ bm::get_block_coord(nblock_right, i_to, j_to);
++ block_idx_type top_size = bman.top_block_size();
++ if (i_to >= top_size)
++ i_to = unsigned(top_size-1);
++
++ ++nb;
++ bm::word_t*** blk_root = bman.top_blocks_root();
++ bm::get_block_coord(nb, i_from, j_from);
++
++ for (unsigned i = i_from; i <= i_to; ++i)
++ {
++ bm::word_t** blk_blk = blk_root[i];
++ if (!blk_blk)
++ return true;
++ if ((bm::word_t*)blk_blk == FULL_BLOCK_FAKE_ADDR)
++ {
++ if (i > i_from)
++ {
++ pos += bm::gap_max_bits * bm::set_sub_array_size;
++ continue;
++ }
++ else
++ {
++ // TODO: optimization to avoid scanning rest of the super block
++ }
++ }
++
++ unsigned j = (i == i_from) ? j_from : 0;
++ do
++ {
++ if ((bm::word_t*)blk_blk == FULL_BLOCK_FAKE_ADDR)
++ {
++ pos += bm::gap_max_bits;
++ continue;
++ }
++
++ block = blk_blk[j];
++ if (!block)
++ return true;
++
++ res = bm::block_find_interval_end(block, 0, &found_nbit);
++ switch (res)
++ {
++ case 0: // not interval (but it was the interval, so last result
++ return true;
++ case 1: // interval found
++ pos += found_nbit+1;
++ return true;
++ case 2: // keep scanning
++ pos += bm::gap_max_bits;
++ break;
++ default:
++ BM_ASSERT(0);
++ } // switch
++ } while (++j < bm::set_sub_array_size);
++ } // for i
++
++ return true;
++}
++
++
++
++//----------------------------------------------------------------------------
++//
++//----------------------------------------------------------------------------
++
++template<typename BV>
++typename interval_enumerator<BV>::size_type
++interval_enumerator<BV>::start() const BMNOEXCEPT
++{
++ return interval_.first;
++}
++
++//----------------------------------------------------------------------------
++
++template<typename BV>
++typename interval_enumerator<BV>::size_type
++interval_enumerator<BV>::end() const BMNOEXCEPT
++{
++ return interval_.second;
++}
++
++//----------------------------------------------------------------------------
++
++template<typename BV>
++bool interval_enumerator<BV>::valid() const BMNOEXCEPT
++{
++ return (interval_.first != bm::id_max);
++}
++
++//----------------------------------------------------------------------------
++
++template<typename BV>
++void interval_enumerator<BV>::invalidate() BMNOEXCEPT
++{
++ interval_.first = interval_.second = bm::id_max;
++}
++
++//----------------------------------------------------------------------------
++
++template<typename BV>
++bool interval_enumerator<BV>::go_to(size_type pos, bool extend_start)
++{
++ return go_to_impl(pos, extend_start);
++}
++
++//----------------------------------------------------------------------------
++
++template<typename BV>
++bool interval_enumerator<BV>::go_to_impl(size_type pos, bool extend_start)
++{
++ if (!bv_ || !bv_->is_init() || (pos >= bm::id_max))
++ {
++ invalidate();
++ return false;
++ }
++
++ bool found;
++ size_type start_pos;
++
++ // go to prolog: identify the true interval start position
++ //
++ if (extend_start)
++ {
++ found = bm::find_interval_start(*bv_, pos, start_pos);
++ if (!found)
++ {
++ found = bv_->find(pos, start_pos);
++ if (!found)
++ {
++ invalidate();
++ return false;
++ }
++ }
++ }
++ else
++ {
++ found = bv_->find(pos, start_pos);
++ if (!found)
++ {
++ invalidate();
++ return false;
++ }
++ }
++
++ // start position established, start decoding from it
++ interval_.first = pos = start_pos;
++
++ block_idx_type nb = (pos >> bm::set_block_shift);
++ const typename BV::blocks_manager_type& bman = bv_->get_blocks_manager();
++ unsigned i0, j0;
++ bm::get_block_coord(nb, i0, j0);
++ const bm::word_t* block = bman.get_block_ptr(i0, j0);
++ BM_ASSERT(block);
++
++ if (block == FULL_BLOCK_FAKE_ADDR)
++ {
++ // super-long interval, find the end of it
++ found = bm::find_interval_end(*bv_, pos, interval_.second);
++ BM_ASSERT(found);
++ gap_ptr_ = 0;
++ return true;
++ }
++
++ if (BM_IS_GAP(block))
++ {
++ const bm::gap_word_t* BMRESTRICT gap_block = BMGAP_PTR(block);
++ unsigned nbit = unsigned(pos & bm::set_block_mask);
++
++ unsigned is_set;
++ unsigned gap_pos = bm::gap_bfind(gap_block, nbit, &is_set);
++ BM_ASSERT(is_set);
++
++ interval_.second = (nb * bm::gap_max_bits) + gap_block[gap_pos];
++ if (gap_block[gap_pos] == bm::gap_max_bits-1)
++ {
++ // it is the end of the GAP block - run search
++ //
++ if (interval_.second == bm::id_max-1)
++ {
++ gap_ptr_ = 0;
++ return true;
++ }
++ found = bm::find_interval_end(*bv_, interval_.second + 1, start_pos);
++ if (found)
++ interval_.second = start_pos;
++ gap_ptr_ = 0;
++ return true;
++ }
++ gap_ptr_ = gap_block + gap_pos;
++ return true;
++ }
++
++ // bit-block: turn to GAP and position there
++ //
++ if (gap_buf_.size() == 0)
++ {
++ gap_buf_.resize(bm::gap_max_bits+64);
++ }
++ bm::gap_word_t* gap_tmp = gap_buf_.data();
++ unsigned len = bm::bit_to_gap(gap_tmp, block, bm::gap_max_bits+64);
++ BM_ASSERT(len);
++
++
++ size_type base_idx = (nb * bm::gap_max_bits);
++ for (unsigned i = 1; i <= len; ++i)
++ {
++ size_type gap_pos = base_idx + gap_tmp[i];
++ if (gap_pos >= pos)
++ {
++ if (gap_tmp[i] == bm::gap_max_bits - 1)
++ {
++ found = bm::find_interval_end(*bv_, gap_pos, interval_.second);
++ BM_ASSERT(found);
++ gap_ptr_ = 0;
++ return true;
++ }
++
++ gap_ptr_ = &gap_tmp[i];
++ interval_.second = gap_pos;
++ return true;
++ }
++ if (gap_tmp[i] == bm::gap_max_bits - 1)
++ break;
++ } // for
++
++ BM_ASSERT(0);
++
++ return false;
++}
++
++//----------------------------------------------------------------------------
++
++template<typename BV>
++bool interval_enumerator<BV>::advance()
++{
++ BM_ASSERT(valid());
++
++ if (interval_.second == bm::id_max-1)
++ {
++ invalidate();
++ return false;
++ }
++ block_idx_type nb = (interval_.first >> bm::set_block_shift);
++
++ bool found;
++ if (gap_ptr_) // in GAP block
++ {
++ ++gap_ptr_; // 0 - GAP
++ if (*gap_ptr_ == bm::gap_max_bits-1) // GAP block end
++ {
++ return go_to_impl(((nb+1) * bm::gap_max_bits), false);
++ }
++ unsigned prev = *gap_ptr_;
++
++ ++gap_ptr_; // 1 - GAP
++ BM_ASSERT(*gap_ptr_ > prev);
++ interval_.first = (nb * bm::gap_max_bits) + prev + 1;
++ if (*gap_ptr_ == bm::gap_max_bits-1) // GAP block end
++ {
++ found = bm::find_interval_end(*bv_, interval_.first, interval_.second);
++ BM_ASSERT(found); (void)found;
++ gap_ptr_ = 0;
++ return true;
++ }
++ interval_.second = (nb * bm::gap_max_bits) + *gap_ptr_;
++ return true;
++ }
++ return go_to_impl(interval_.second + 1, false);
++}
++
++//----------------------------------------------------------------------------
++
++template<typename BV>
++void interval_enumerator<BV>::swap(interval_enumerator<BV>& ien) BMNOEXCEPT
++{
++ const BV* bv_tmp = bv_;
++ bv_ = ien.bv_;
++ ien.bv_ = bv_tmp;
++
++ gap_buf_.swap(ien.gap_buf_);
++ bm::xor_swap(interval_.first, ien.interval_.first);
++ bm::xor_swap(interval_.second, ien.interval_.second);
++
++ const bm::gap_word_t* gap_tmp = gap_ptr_;
++ gap_ptr_ = ien.gap_ptr_;
++ ien.gap_ptr_ = gap_tmp;
++}
++
++//----------------------------------------------------------------------------
++//
++//----------------------------------------------------------------------------
++
++
++} // namespace bm
++
++#include "bmundef.h"
++
++#endif
+
+Property changes on: c++/include/util/bitset/bmintervals.h
+___________________________________________________________________
+Added: svn:eol-style
+## -0,0 +1 ##
++native
+\ No newline at end of property
+Added: svn:keywords
+## -0,0 +1 ##
++Id
+\ No newline at end of property
+Added: svn:mime-type
+## -0,0 +1 ##
++text/x-c
+\ No newline at end of property
+Index: c++/include/util/bitset/encoding.h
+===================================================================
+--- a/c++/include/util/bitset/encoding.h (revision 90103)
++++ b/c++/include/util/bitset/encoding.h (revision 90104)
+@@ -51,24 +51,24 @@
+ public:
+ typedef unsigned char* position_type;
+ public:
+- encoder(unsigned char* buf, size_t size);
+- void put_8(unsigned char c);
+- void put_16(bm::short_t s);
+- void put_16(const bm::short_t* s, unsigned count);
+- void put_24(bm::word_t w);
+- void put_32(bm::word_t w);
+- void put_32(const bm::word_t* w, unsigned count);
+- void put_48(bm::id64_t w);
+- void put_64(bm::id64_t w);
++ encoder(unsigned char* buf, size_t size) BMNOEXCEPT;
++ void put_8(unsigned char c) BMNOEXCEPT;
++ void put_16(bm::short_t s) BMNOEXCEPT;
++ void put_16(const bm::short_t* s, unsigned count) BMNOEXCEPT;
++ void put_24(bm::word_t w) BMNOEXCEPT;
++ void put_32(bm::word_t w) BMNOEXCEPT;
++ void put_32(const bm::word_t* w, unsigned count) BMNOEXCEPT;
++ void put_48(bm::id64_t w) BMNOEXCEPT;
++ void put_64(bm::id64_t w) BMNOEXCEPT;
+ void put_prefixed_array_32(unsigned char c,
+- const bm::word_t* w, unsigned count);
++ const bm::word_t* w, unsigned count) BMNOEXCEPT;
+ void put_prefixed_array_16(unsigned char c,
+ const bm::short_t* s, unsigned count,
+- bool encode_count);
+- void memcpy(const unsigned char* src, size_t count);
+- size_t size() const;
+- unsigned char* get_pos() const;
+- void set_pos(unsigned char* buf_pos);
++ bool encode_count) BMNOEXCEPT;
++ void memcpy(const unsigned char* src, size_t count) BMNOEXCEPT;
++ size_t size() const BMNOEXCEPT;
++ unsigned char* get_pos() const BMNOEXCEPT;
++ void set_pos(unsigned char* buf_pos) BMNOEXCEPT;
+ private:
+ unsigned char* buf_;
+ unsigned char* start_;
+@@ -83,25 +83,25 @@
+ class decoder_base
+ {
+ public:
+- decoder_base(const unsigned char* buf) { buf_ = start_ = buf; }
++ decoder_base(const unsigned char* buf) BMNOEXCEPT { buf_ = start_ = buf; }
+
+ /// Reads character from the decoding buffer.
+- unsigned char get_8() { return *buf_++; }
++ unsigned char get_8() BMNOEXCEPT { return *buf_++; }
+
+ /// Returns size of the current decoding stream.
+- size_t size() const { return size_t(buf_ - start_); }
++ size_t size() const BMNOEXCEPT { return size_t(buf_ - start_); }
+
+ /// change current position
+- void seek(int delta) { buf_ += delta; }
++ void seek(int delta) BMNOEXCEPT { buf_ += delta; }
+
+ /// read bytes from the decode buffer
+- void memcpy(unsigned char* dst, size_t count);
++ void memcpy(unsigned char* dst, size_t count) BMNOEXCEPT;
+
+ /// Return current buffer pointer
+- const unsigned char* get_pos() const { return buf_; }
++ const unsigned char* get_pos() const BMNOEXCEPT { return buf_; }
+
+ /// Set current buffer pointer
+- void set_pos(const unsigned char* pos) { buf_ = pos; }
++ void set_pos(const unsigned char* pos) BMNOEXCEPT { buf_ = pos; }
+ protected:
+ const unsigned char* buf_;
+ const unsigned char* start_;
+@@ -117,16 +117,16 @@
+ class decoder : public decoder_base
+ {
+ public:
+- decoder(const unsigned char* buf);
+- bm::short_t get_16();
+- bm::word_t get_24();
+- bm::word_t get_32();
+- bm::id64_t get_48();
+- bm::id64_t get_64();
+- void get_32(bm::word_t* w, unsigned count);
+- bool get_32_OR(bm::word_t* w, unsigned count);
+- void get_32_AND(bm::word_t* w, unsigned count);
+- void get_16(bm::short_t* s, unsigned count);
++ decoder(const unsigned char* buf) BMNOEXCEPT;
++ bm::short_t get_16() BMNOEXCEPT;
++ bm::word_t get_24() BMNOEXCEPT;
++ bm::word_t get_32() BMNOEXCEPT;
++ bm::id64_t get_48() BMNOEXCEPT;
++ bm::id64_t get_64() BMNOEXCEPT;
++ void get_32(bm::word_t* w, unsigned count) BMNOEXCEPT;
++ bool get_32_OR(bm::word_t* w, unsigned count) BMNOEXCEPT;
++ void get_32_AND(bm::word_t* w, unsigned count) BMNOEXCEPT;
++ void get_16(bm::short_t* s, unsigned count) BMNOEXCEPT;
+ };
+
+ // ----------------------------------------------------------------
+@@ -181,23 +181,23 @@
+ ~bit_out() { flush(); }
+
+ /// issue single bit into encode bit-stream
+- void put_bit(unsigned value);
++ void put_bit(unsigned value) BMNOEXCEPT;
+
+ /// issue count bits out of value
+- void put_bits(unsigned value, unsigned count);
++ void put_bits(unsigned value, unsigned count) BMNOEXCEPT;
+
+ /// issue 0 into output stream
+- void put_zero_bit();
++ void put_zero_bit() BMNOEXCEPT;
+
+ /// issue specified number of 0s
+- void put_zero_bits(unsigned count);
++ void put_zero_bits(unsigned count) BMNOEXCEPT;
+
+ /// Elias Gamma encode the specified value
+- void gamma(unsigned value);
++ void gamma(unsigned value) BMNOEXCEPT;
+
+ /// Binary Interpolative array decode
+ void bic_encode_u16(const bm::gap_word_t* arr, unsigned sz,
+- bm::gap_word_t lo, bm::gap_word_t hi)
++ bm::gap_word_t lo, bm::gap_word_t hi) BMNOEXCEPT
+ {
+ bic_encode_u16_cm(arr, sz, lo, hi);
+ }
+@@ -205,24 +205,24 @@
+ /// Binary Interpolative encoding (array of 16-bit ints)
+ void bic_encode_u16_rg(const bm::gap_word_t* arr, unsigned sz,
+ bm::gap_word_t lo,
+- bm::gap_word_t hi);
++ bm::gap_word_t hi) BMNOEXCEPT;
+
+ /// Binary Interpolative encoding (array of 16-bit ints)
+ /// cm - "center-minimal"
+ void bic_encode_u16_cm(const bm::gap_word_t* arr, unsigned sz,
+ bm::gap_word_t lo,
+- bm::gap_word_t hi);
++ bm::gap_word_t hi) BMNOEXCEPT;
+
+ /// Binary Interpolative encoding (array of 32-bit ints)
+ /// cm - "center-minimal"
+ void bic_encode_u32_cm(const bm::word_t* arr, unsigned sz,
+- bm::word_t lo, bm::word_t hi);
++ bm::word_t lo, bm::word_t hi) BMNOEXCEPT;
+
+ /// Flush the incomplete 32-bit accumulator word
+- void flush() { if (used_bits_) flush_accum(); }
++ void flush() BMNOEXCEPT { if (used_bits_) flush_accum(); }
+
+ private:
+- void flush_accum()
++ void flush_accum() BMNOEXCEPT
+ {
+ dest_.put_32(accum_);
+ used_bits_ = accum_ = 0;
+@@ -248,31 +248,32 @@
+ class bit_in
+ {
+ public:
+- bit_in(TDecoder& decoder)
++ bit_in(TDecoder& decoder) BMNOEXCEPT
+ : src_(decoder),
+ used_bits_(unsigned(sizeof(accum_) * 8)),
+- accum_(0)
++ accum_(0)
+ {}
+
+ /// decode unsigned value using Elias Gamma coding
+- unsigned gamma();
++ unsigned gamma() BMNOEXCEPT;
+
+ /// read number of bits out of the stream
+- unsigned get_bits(unsigned count);
++ unsigned get_bits(unsigned count) BMNOEXCEPT;
+
+ /// Binary Interpolative array decode
+ void bic_decode_u16(bm::gap_word_t* arr, unsigned sz,
+- bm::gap_word_t lo, bm::gap_word_t hi)
++ bm::gap_word_t lo, bm::gap_word_t hi) BMNOEXCEPT
+ {
+ bic_decode_u16_cm(arr, sz, lo, hi);
+ }
+
+ void bic_decode_u16_bitset(bm::word_t* block, unsigned sz,
+- bm::gap_word_t lo, bm::gap_word_t hi)
++ bm::gap_word_t lo, bm::gap_word_t hi) BMNOEXCEPT
+ {
+ bic_decode_u16_cm_bitset(block, sz, lo, hi);
+ }
+- void bic_decode_u16_dry(unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi)
++ void bic_decode_u16_dry(unsigned sz,
++ bm::gap_word_t lo, bm::gap_word_t hi) BMNOEXCEPT
+ {
+ bic_decode_u16_cm_dry(sz, lo, hi);
+ }
+@@ -280,29 +281,32 @@
+
+ /// Binary Interpolative array decode
+ void bic_decode_u16_rg(bm::gap_word_t* arr, unsigned sz,
+- bm::gap_word_t lo, bm::gap_word_t hi);
++ bm::gap_word_t lo, bm::gap_word_t hi) BMNOEXCEPT;
+ /// Binary Interpolative array decode
+ void bic_decode_u16_cm(bm::gap_word_t* arr, unsigned sz,
+- bm::gap_word_t lo, bm::gap_word_t hi);
++ bm::gap_word_t lo, bm::gap_word_t hi) BMNOEXCEPT;
+
+ /// Binary Interpolative array decode (32-bit)
+ void bic_decode_u32_cm(bm::word_t* arr, unsigned sz,
+- bm::word_t lo, bm::word_t hi);
++ bm::word_t lo, bm::word_t hi) BMNOEXCEPT;
+
+
+ /// Binary Interpolative array decode into bitset (32-bit based)
+ void bic_decode_u16_rg_bitset(bm::word_t* block, unsigned sz,
+- bm::gap_word_t lo, bm::gap_word_t hi);
++ bm::gap_word_t lo, bm::gap_word_t hi) BMNOEXCEPT;
+
+ /// Binary Interpolative array decode into /dev/null
+- void bic_decode_u16_rg_dry(unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi);
++ void bic_decode_u16_rg_dry(unsigned sz,
++ bm::gap_word_t lo, bm::gap_word_t hi) BMNOEXCEPT;
+
+ /// Binary Interpolative array decode into bitset (32-bit based)
+ void bic_decode_u16_cm_bitset(bm::word_t* block, unsigned sz,
+- bm::gap_word_t lo, bm::gap_word_t hi);
++ bm::gap_word_t lo,
++ bm::gap_word_t hi) BMNOEXCEPT;
+
+ /// Binary Interpolative array decode into /dev/null
+- void bic_decode_u16_cm_dry(unsigned sz, bm::gap_word_t lo, bm::gap_word_t hi);
++ void bic_decode_u16_cm_dry(unsigned sz,
++ bm::gap_word_t lo, bm::gap_word_t hi) BMNOEXCEPT;
+
+ private:
+ bit_in(const bit_in&);
+@@ -377,7 +381,7 @@
+ \param buf - memory buffer pointer.
+ \param size - size of the buffer
+ */
+-inline encoder::encoder(unsigned char* buf, size_t a_size)
++inline encoder::encoder(unsigned char* buf, size_t a_size) BMNOEXCEPT
+ : buf_(buf), start_(buf)
+ {
+ size_ = a_size;
+@@ -387,7 +391,7 @@
+ */
+ inline void encoder::put_prefixed_array_32(unsigned char c,
+ const bm::word_t* w,
+- unsigned count)
++ unsigned count) BMNOEXCEPT
+ {
+ put_8(c);
+ put_32(w, count);
+@@ -399,7 +403,7 @@
+ inline void encoder::put_prefixed_array_16(unsigned char c,
+ const bm::short_t* s,
+ unsigned count,
+- bool encode_count)
++ bool encode_count) BMNOEXCEPT
+ {
+ put_8(c);
+ if (encode_count)
+@@ -413,7 +417,7 @@
+ \brief Puts one character into the encoding buffer.
+ \param c - character to encode
+ */
+-BMFORCEINLINE void encoder::put_8(unsigned char c)
++BMFORCEINLINE void encoder::put_8(unsigned char c) BMNOEXCEPT
+ {
+ *buf_++ = c;
+ }
+@@ -423,7 +427,7 @@
+ \brief Puts short word (16 bits) into the encoding buffer.
+ \param s - short word to encode
+ */
+-BMFORCEINLINE void encoder::put_16(bm::short_t s)
++BMFORCEINLINE void encoder::put_16(bm::short_t s) BMNOEXCEPT
+ {
+ #if (BM_UNALIGNED_ACCESS_OK == 1)
+ ::memcpy(buf_, &s, sizeof(bm::short_t)); // optimizer takes care of it
+@@ -438,7 +442,7 @@
+ /*!
+ \brief Method puts array of short words (16 bits) into the encoding buffer.
+ */
+-inline void encoder::put_16(const bm::short_t* s, unsigned count)
++inline void encoder::put_16(const bm::short_t* s, unsigned count) BMNOEXCEPT
+ {
+ #if (BM_UNALIGNED_ACCESS_OK == 1)
+ ::memcpy(buf_, s, sizeof(bm::short_t)*count);
+@@ -465,7 +469,7 @@
+ \brief copy bytes into target buffer or just rewind if src is NULL
+ */
+ inline
+-void encoder::memcpy(const unsigned char* src, size_t count)
++void encoder::memcpy(const unsigned char* src, size_t count) BMNOEXCEPT
+ {
+ BM_ASSERT((buf_ + count) < (start_ + size_));
+ if (src)
+@@ -478,7 +482,7 @@
+ \fn unsigned encoder::size() const
+ \brief Returns size of the current encoding stream.
+ */
+-inline size_t encoder::size() const
++inline size_t encoder::size() const BMNOEXCEPT
+ {
+ return size_t(buf_ - start_);
+ }
+@@ -486,7 +490,7 @@
+ /**
+ \brief Get current memory stream position
+ */
+-inline encoder::position_type encoder::get_pos() const
++inline encoder::position_type encoder::get_pos() const BMNOEXCEPT
+ {
+ return buf_;
+ }
+@@ -494,7 +498,7 @@
+ /**
+ \brief Set current memory stream position
+ */
+-inline void encoder::set_pos(encoder::position_type buf_pos)
++inline void encoder::set_pos(encoder::position_type buf_pos) BMNOEXCEPT
+ {
+ buf_ = buf_pos;
+ }
+@@ -504,7 +508,7 @@
+ \brief Puts 24 bits word into encoding buffer.
+ \param w - word to encode.
+ */
+-inline void encoder::put_24(bm::word_t w)
++inline void encoder::put_24(bm::word_t w) BMNOEXCEPT
+ {
+ BM_ASSERT((w & ~(0xFFFFFFU)) == 0);
+
+@@ -520,7 +524,7 @@
+ \brief Puts 32 bits word into encoding buffer.
+ \param w - word to encode.
+ */
+-inline void encoder::put_32(bm::word_t w)
++inline void encoder::put_32(bm::word_t w) BMNOEXCEPT
+ {
+ #if (BM_UNALIGNED_ACCESS_OK == 1)
+ ::memcpy(buf_, &w, sizeof(bm::word_t));
+@@ -538,7 +542,7 @@
+ \brief Puts 48 bits word into encoding buffer.
+ \param w - word to encode.
+ */
+-inline void encoder::put_48(bm::id64_t w)
++inline void encoder::put_48(bm::id64_t w) BMNOEXCEPT
+ {
+ BM_ASSERT((w & ~(0xFFFFFFFFFFFFUL)) == 0);
+ *buf_++ = (unsigned char)w;
+@@ -555,7 +559,7 @@
+ \brief Puts 64 bits word into encoding buffer.
+ \param w - word to encode.
+ */
+-inline void encoder::put_64(bm::id64_t w)
++inline void encoder::put_64(bm::id64_t w) BMNOEXCEPT
+ {
+ #if (BM_UNALIGNED_ACCESS_OK == 1)
+ ::memcpy(buf_, &w, sizeof(bm::id64_t));
+@@ -576,10 +580,10 @@
+ /*!
+ \brief Encodes array of 32-bit words
+ */
+-inline
+-void encoder::put_32(const bm::word_t* w, unsigned count)
++inline void encoder::put_32(const bm::word_t* w, unsigned count) BMNOEXCEPT
+ {
+ #if (BM_UNALIGNED_ACCESS_OK == 1)
++ // use memcpy() because compilers now understand it as an idiom and inline
+ ::memcpy(buf_, w, sizeof(bm::word_t) * count);
+ buf_ += sizeof(bm::word_t) * count;
+ #else
+@@ -611,7 +615,7 @@
+ Load bytes from the decode buffer
+ */
+ inline
+-void decoder_base::memcpy(unsigned char* dst, size_t count)
++void decoder_base::memcpy(unsigned char* dst, size_t count) BMNOEXCEPT
+ {
+ if (dst)
+ ::memcpy(dst, buf_, count);
+@@ -623,7 +627,7 @@
+ \brief Construction
+ \param buf - pointer to the decoding memory.
+ */
+-inline decoder::decoder(const unsigned char* buf)
++inline decoder::decoder(const unsigned char* buf) BMNOEXCEPT
+ : decoder_base(buf)
+ {
+ }
+@@ -632,7 +636,7 @@
+ \fn bm::short_t decoder::get_16()
+ \brief Reads 16-bit word from the decoding buffer.
+ */
+-BMFORCEINLINE bm::short_t decoder::get_16()
++BMFORCEINLINE bm::short_t decoder::get_16() BMNOEXCEPT
+ {
+ #if (BM_UNALIGNED_ACCESS_OK == 1)
+ bm::short_t a;
+@@ -648,7 +652,7 @@
+ \fn bm::word_t decoder::get_24()
+ \brief Reads 32-bit word from the decoding buffer.
+ */
+-inline bm::word_t decoder::get_24()
++inline bm::word_t decoder::get_24() BMNOEXCEPT
+ {
+ bm::word_t a = buf_[0] + ((unsigned)buf_[1] << 8) +
+ ((unsigned)buf_[2] << 16);
+@@ -661,7 +665,7 @@
+ \fn bm::word_t decoder::get_32()
+ \brief Reads 32-bit word from the decoding buffer.
+ */
+-BMFORCEINLINE bm::word_t decoder::get_32()
++BMFORCEINLINE bm::word_t decoder::get_32() BMNOEXCEPT
+ {
+ #if (BM_UNALIGNED_ACCESS_OK == 1)
+ bm::word_t a;
+@@ -679,7 +683,7 @@
+ \brief Reads 64-bit word from the decoding buffer.
+ */
+ inline
+-bm::id64_t decoder::get_48()
++bm::id64_t decoder::get_48() BMNOEXCEPT
+ {
+ bm::id64_t a = buf_[0] +
+ ((bm::id64_t)buf_[1] << 8) +
+@@ -696,7 +700,7 @@
+ \brief Reads 64-bit word from the decoding buffer.
+ */
+ inline
+-bm::id64_t decoder::get_64()
++bm::id64_t decoder::get_64() BMNOEXCEPT
+ {
+ #if (BM_UNALIGNED_ACCESS_OK == 1)
+ bm::id64_t a;
+@@ -722,7 +726,7 @@
+ \param w - pointer on memory block to read into.
+ \param count - size of memory block in words.
+ */
+-inline void decoder::get_32(bm::word_t* w, unsigned count)
++inline void decoder::get_32(bm::word_t* w, unsigned count) BMNOEXCEPT
+ {
+ if (!w)
+ {
+@@ -754,7 +758,7 @@
+ \param count - should match bm::set_block_size
+ */
+ inline
+-bool decoder::get_32_OR(bm::word_t* w, unsigned count)
++bool decoder::get_32_OR(bm::word_t* w, unsigned count) BMNOEXCEPT
+ {
+ if (!w)
+ {
+@@ -795,7 +799,7 @@
+ \param count - should match bm::set_block_size
+ */
+ inline
+-void decoder::get_32_AND(bm::word_t* w, unsigned count)
++void decoder::get_32_AND(bm::word_t* w, unsigned count) BMNOEXCEPT
+ {
+ if (!w)
+ {
+@@ -833,7 +837,7 @@
+ \param s - pointer on memory block to read into.
+ \param count - size of memory block in words.
+ */
+-inline void decoder::get_16(bm::short_t* s, unsigned count)
++inline void decoder::get_16(bm::short_t* s, unsigned count) BMNOEXCEPT
+ {
+ if (!s)
+ {
+@@ -1004,7 +1008,7 @@
+ //
+
+ template<typename TEncoder>
+-void bit_out<TEncoder>::put_bit(unsigned value)
++void bit_out<TEncoder>::put_bit(unsigned value) BMNOEXCEPT
+ {
+ BM_ASSERT(value <= 1);
+ accum_ |= (value << used_bits_);
+@@ -1015,7 +1019,7 @@
+ // ----------------------------------------------------------------------
+
+ template<typename TEncoder>
+-void bit_out<TEncoder>::put_bits(unsigned value, unsigned count)
++void bit_out<TEncoder>::put_bits(unsigned value, unsigned count) BMNOEXCEPT
+ {
+ unsigned used = used_bits_;
+ unsigned acc = accum_;
+@@ -1057,7 +1061,7 @@
+ // ----------------------------------------------------------------------
+
+ template<typename TEncoder>
+-void bit_out<TEncoder>::put_zero_bit()
++void bit_out<TEncoder>::put_zero_bit() BMNOEXCEPT
+ {
+ if (++used_bits_ == (sizeof(accum_) * 8))
+ flush_accum();
+@@ -1066,7 +1070,7 @@
+ // ----------------------------------------------------------------------
+
+ template<typename TEncoder>
+-void bit_out<TEncoder>::put_zero_bits(unsigned count)
++void bit_out<TEncoder>::put_zero_bits(unsigned count) BMNOEXCEPT
+ {
+ unsigned used = used_bits_;
+ unsigned free_bits = (sizeof(accum_) * 8) - used;
+@@ -1096,7 +1100,7 @@
+ // ----------------------------------------------------------------------
+
+ template<typename TEncoder>
+-void bit_out<TEncoder>::gamma(unsigned value)
++void bit_out<TEncoder>::gamma(unsigned value) BMNOEXCEPT
+ {
+ BM_ASSERT(value);
+
+@@ -1168,9 +1172,10 @@
+ // ----------------------------------------------------------------------
+
+ template<typename TEncoder>
+-void bit_out<TEncoder>::bic_encode_u16_rg(const bm::gap_word_t* arr,
+- unsigned sz,
+- bm::gap_word_t lo, bm::gap_word_t hi)
++void bit_out<TEncoder>::bic_encode_u16_rg(
++ const bm::gap_word_t* arr,
++ unsigned sz,
++ bm::gap_word_t lo, bm::gap_word_t hi) BMNOEXCEPT
+ {
+ for (;sz;)
+ {
+@@ -1204,7 +1209,8 @@
+ template<typename TEncoder>
+ void bit_out<TEncoder>::bic_encode_u32_cm(const bm::word_t* arr,
+ unsigned sz,
+- bm::word_t lo, bm::word_t hi)
++ bm::word_t lo,
++ bm::word_t hi) BMNOEXCEPT
+ {
+ for (;sz;)
+ {
+@@ -1292,7 +1298,7 @@
+ void bit_out<TEncoder>::bic_encode_u16_cm(const bm::gap_word_t* arr,
+ unsigned sz_i,
+ bm::gap_word_t lo_i,
+- bm::gap_word_t hi_i)
++ bm::gap_word_t hi_i) BMNOEXCEPT
+ {
+ BM_ASSERT(sz_i <= 65535);
+
+@@ -1329,7 +1335,8 @@
+ template<typename TEncoder>
+ void bit_out<TEncoder>::bic_encode_u16_cm(const bm::gap_word_t* arr,
+ unsigned sz,
+- bm::gap_word_t lo, bm::gap_word_t hi)
++ bm::gap_word_t lo,
++ bm::gap_word_t hi) BMNOEXCEPT
+ {
+ for (;sz;)
+ {
+@@ -1379,7 +1386,8 @@
+
+ template<class TDecoder>
+ void bit_in<TDecoder>::bic_decode_u16_rg(bm::gap_word_t* arr, unsigned sz,
+- bm::gap_word_t lo, bm::gap_word_t hi)
++ bm::gap_word_t lo,
++ bm::gap_word_t hi) BMNOEXCEPT
+ {
+ for (;sz;)
+ {
+@@ -1421,7 +1429,8 @@
+
+ template<class TDecoder>
+ void bit_in<TDecoder>::bic_decode_u32_cm(bm::word_t* arr, unsigned sz,
+- bm::word_t lo, bm::word_t hi)
++ bm::word_t lo,
++ bm::word_t hi) BMNOEXCEPT
+ {
+ for (;sz;)
+ {
+@@ -1472,7 +1481,8 @@
+
+ template<class TDecoder>
+ void bit_in<TDecoder>::bic_decode_u16_cm(bm::gap_word_t* arr, unsigned sz,
+- bm::gap_word_t lo, bm::gap_word_t hi)
++ bm::gap_word_t lo,
++ bm::gap_word_t hi) BMNOEXCEPT
+ {
+ for (;sz;)
+ {
+@@ -1523,7 +1533,8 @@
+
+ template<class TDecoder>
+ void bit_in<TDecoder>::bic_decode_u16_cm_bitset(bm::word_t* block, unsigned sz,
+- bm::gap_word_t lo, bm::gap_word_t hi)
++ bm::gap_word_t lo,
++ bm::gap_word_t hi) BMNOEXCEPT
+ {
+ for (;sz;)
+ {
+@@ -1579,7 +1590,8 @@
+
+ template<class TDecoder>
+ void bit_in<TDecoder>::bic_decode_u16_cm_dry(unsigned sz,
+- bm::gap_word_t lo, bm::gap_word_t hi)
++ bm::gap_word_t lo,
++ bm::gap_word_t hi) BMNOEXCEPT
+ {
+ for (;sz;)
+ {
+@@ -1630,7 +1642,8 @@
+
+ template<class TDecoder>
+ void bit_in<TDecoder>::bic_decode_u16_rg_bitset(bm::word_t* block, unsigned sz,
+- bm::gap_word_t lo, bm::gap_word_t hi)
++ bm::gap_word_t lo,
++ bm::gap_word_t hi) BMNOEXCEPT
+ {
+ for (;sz;)
+ {
+@@ -1665,7 +1678,7 @@
+ if (sz == 1)
+ return;
+ bic_decode_u16_rg_bitset(block, mid_idx, lo, bm::gap_word_t(val - 1));
+- // tail recursion:
++ // tail recursion of:
+ //bic_decode_u16_bitset(block, sz - mid_idx - 1, bm::gap_word_t(val + 1), hi);
+ sz -= mid_idx + 1;
+ lo = bm::gap_word_t(val + 1);
+@@ -1676,7 +1689,8 @@
+
+ template<class TDecoder>
+ void bit_in<TDecoder>::bic_decode_u16_rg_dry(unsigned sz,
+- bm::gap_word_t lo, bm::gap_word_t hi)
++ bm::gap_word_t lo,
++ bm::gap_word_t hi) BMNOEXCEPT
+ {
+ for (;sz;)
+ {
+@@ -1705,7 +1719,6 @@
+ if (sz == 1)
+ return;
+ bic_decode_u16_rg_dry(mid_idx, lo, bm::gap_word_t(val - 1));
+- //bic_decode_u16_dry(sz - mid_idx - 1, bm::gap_word_t(val + 1), hi);
+ sz -= mid_idx + 1;
+ lo = bm::gap_word_t(val + 1);
+ } // for sz
+@@ -1716,7 +1729,7 @@
+ // ----------------------------------------------------------------------
+
+ template<class TDecoder>
+-unsigned bit_in<TDecoder>::gamma()
++unsigned bit_in<TDecoder>::gamma() BMNOEXCEPT
+ {
+ unsigned acc = accum_;
+ unsigned used = used_bits_;
+@@ -1801,7 +1814,7 @@
+ // ----------------------------------------------------------------------
+
+ template<class TDecoder>
+-unsigned bit_in<TDecoder>::get_bits(unsigned count)
++unsigned bit_in<TDecoder>::get_bits(unsigned count) BMNOEXCEPT
+ {
+ BM_ASSERT(count);
+ const unsigned maskFF = ~0u;
+Index: c++/include/util/bitset/bmxor.h
+===================================================================
+--- a/c++/include/util/bitset/bmxor.h (revision 90103)
++++ b/c++/include/util/bitset/bmxor.h (revision 90104)
+@@ -36,7 +36,7 @@
+ inline
+ unsigned bit_block_xor_change32(const bm::word_t* BMRESTRICT block,
+ const bm::word_t* BMRESTRICT xor_block,
+- unsigned size)
++ unsigned size) BMNOEXCEPT
+ {
+ unsigned gap_count = 1;
+
+@@ -80,7 +80,7 @@
+ inline
+ unsigned bit_block_xor_change(const bm::word_t* BMRESTRICT block,
+ const bm::word_t* BMRESTRICT xor_block,
+- unsigned size)
++ unsigned size) BMNOEXCEPT
+ {
+ #ifdef VECT_BLOCK_XOR_CHANGE
+ return VECT_BLOCK_XOR_CHANGE(block, xor_block, size);
+@@ -112,7 +112,7 @@
+ inline
+ void compute_complexity_descr(
+ const bm::word_t* BMRESTRICT block,
+- block_waves_xor_descr& BMRESTRICT x_descr)
++ block_waves_xor_descr& BMRESTRICT x_descr) BMNOEXCEPT
+ {
+ for (unsigned i = 0; i < bm::block_waves; ++i)
+ {
+@@ -146,7 +146,7 @@
+ const bm::word_t* BMRESTRICT block,
+ const bm::word_t* BMRESTRICT xor_block,
+ block_waves_xor_descr& BMRESTRICT x_descr,
+- unsigned& block_gain)
++ unsigned& BMRESTRICT block_gain) BMNOEXCEPT
+ {
+ block_gain = 0; // approximate block gain (sum of sub-waves)
+ bm::id64_t digest = 0;
+@@ -191,7 +191,7 @@
+ inline
+ void bit_block_xor(bm::word_t* target_block,
+ const bm::word_t* block, const bm::word_t* xor_block,
+- bm::id64_t digest)
++ bm::id64_t digest) BMNOEXCEPT
+ {
+ BM_ASSERT(target_block);
+ BM_ASSERT(block);
+@@ -267,21 +267,23 @@
+ }
+
+ /// Get reference list size
+- size_type size() const { return (size_type)ref_bvects_.size(); }
++ size_type size() const BMNOEXCEPT { return (size_type)ref_bvects_.size(); }
+
+ /// Get reference vector by the index in this ref-vector
+- const bvector_type* get_bv(size_type idx) const { return ref_bvects_[idx]; }
++ const bvector_type* get_bv(size_type idx) const BMNOEXCEPT
++ { return ref_bvects_[idx]; }
+
+ /// Get reference row index by the index in this ref-vector
+- size_type get_row_idx(size_type idx) const { return (size_type)ref_bvects_rows_[idx]; }
++ size_type get_row_idx(size_type idx) const BMNOEXCEPT
++ { return (size_type)ref_bvects_rows_[idx]; }
+
+ /// not-found value for find methods
+ static
+- size_type not_found() { return ~(size_type(0)); }
++ size_type not_found() BMNOEXCEPT { return ~(size_type(0)); }
+
+ /// Find vector index by the reference index
+ /// @return ~0 if not found
+- size_type find(std::size_t ref_idx) const
++ size_type find(std::size_t ref_idx) const BMNOEXCEPT
+ {
+ size_type sz = size();
+ for (size_type i = 0; i < sz; ++i)
+@@ -333,13 +335,16 @@
+ typedef typename bvector_type::size_type size_type;
+
+ public:
+- void set_ref_vector(const bv_ref_vector_type* ref_vect) { ref_vect_ = ref_vect; }
+- const bv_ref_vector_type& get_ref_vector() const { return *ref_vect_; }
++ void set_ref_vector(const bv_ref_vector_type* ref_vect) BMNOEXCEPT
++ { ref_vect_ = ref_vect; }
+
++ const bv_ref_vector_type& get_ref_vector() const BMNOEXCEPT
++ { return *ref_vect_; }
++
+ /** Compute statistics for the anchor search vector
+ @param block - bit-block target
+ */
+- void compute_x_block_stats(const bm::word_t* block);
++ void compute_x_block_stats(const bm::word_t* block) BMNOEXCEPT;
+
+ /** Scan for all candidate bit-blocks to find mask or match
+ @return true if XOR complement or matching vector found
+@@ -360,23 +365,26 @@
+ /**
+ Validate serialization target
+ */
+- bool validate_found(bm::word_t* xor_block, const bm::word_t* block) const;
++ bool validate_found(bm::word_t* xor_block,
++ const bm::word_t* block) const BMNOEXCEPT;
+
+- size_type found_ridx() const { return found_ridx_; }
+- const bm::word_t* get_found_block() const { return found_block_xor_; }
+- unsigned get_x_best_metric() const { return x_best_metric_; }
+- bm::id64_t get_xor_digest() const { return x_d64_; }
++ size_type found_ridx() const BMNOEXCEPT { return found_ridx_; }
++ const bm::word_t* get_found_block() const BMNOEXCEPT
++ { return found_block_xor_; }
++ unsigned get_x_best_metric() const BMNOEXCEPT { return x_best_metric_; }
++ bm::id64_t get_xor_digest() const BMNOEXCEPT { return x_d64_; }
+
+ /// true if completely identical vector found
+- bool is_eq_found() const { return !x_best_metric_; }
++ bool is_eq_found() const BMNOEXCEPT { return !x_best_metric_; }
+
+
+- unsigned get_x_bc() const { return x_bc_; }
+- unsigned get_x_gc() const { return x_gc_; }
+- unsigned get_x_block_best() const { return x_block_best_metric_; }
++ unsigned get_x_bc() const BMNOEXCEPT { return x_bc_; }
++ unsigned get_x_gc() const BMNOEXCEPT { return x_gc_; }
++ unsigned get_x_block_best() const BMNOEXCEPT
++ { return x_block_best_metric_; }
+
+
+- bm::block_waves_xor_descr& get_descr() { return x_descr_; }
++ bm::block_waves_xor_descr& get_descr() BMNOEXCEPT { return x_descr_; }
+
+ private:
+ const bv_ref_vector_type* ref_vect_ = 0; ///< ref.vect for XOR filter
+@@ -400,7 +408,7 @@
+ // --------------------------------------------------------------------------
+
+ template<typename BV>
+-void xor_scanner<BV>::compute_x_block_stats(const bm::word_t* block)
++void xor_scanner<BV>::compute_x_block_stats(const bm::word_t* block) BMNOEXCEPT
+ {
+ BM_ASSERT(IS_VALID_ADDR(block));
+ BM_ASSERT(!BM_IS_GAP(block));
+@@ -439,7 +447,8 @@
+ {
+ const bvector_type* bv = ref_vect_->get_bv(ri);
+ BM_ASSERT(bv);
+- const typename bvector_type::blocks_manager_type& bman = bv->get_blocks_manager();
++ const typename bvector_type::blocks_manager_type& bman =
++ bv->get_blocks_manager();
+ const bm::word_t* block_xor = bman.get_block_ptr(i, j);
+ if (!IS_VALID_ADDR(block_xor) || BM_IS_GAP(block_xor))
+ continue;
+@@ -487,7 +496,7 @@
+ if (!xor_bc) // completely identical block?
+ {
+ unsigned pos;
+- bool f = bit_find_first_diff(block, block_xor, &pos);
++ bool f = bm::bit_find_first_diff(block, block_xor, &pos);
+ x_best_metric_ += f;
+ }
+ }
+@@ -555,7 +564,7 @@
+
+ template<typename BV>
+ bool xor_scanner<BV>::validate_found(bm::word_t* xor_block,
+- const bm::word_t* block) const
++ const bm::word_t* block) const BMNOEXCEPT
+ {
+ bm::id64_t d64 = get_xor_digest();
+ BM_ASSERT(d64);
+Index: c++/include/util/bitset/bmsse2.h
+===================================================================
+--- a/c++/include/util/bitset/bmsse2.h (revision 90103)
++++ b/c++/include/util/bitset/bmsse2.h (revision 90104)
+@@ -398,6 +398,74 @@
+ }
+ return size;
+ }
++
++/**
++ Hybrid binary search, starts as binary, then switches to linear scan
++
++ \param buf - GAP buffer pointer.
++ \param pos - index of the element.
++ \param is_set - output. GAP value (0 or 1).
++ \return GAP index.
++
++ @ingroup SSE2
++*/
++inline
++unsigned sse2_gap_bfind(const unsigned short* BMRESTRICT buf,
++ unsigned pos, unsigned* BMRESTRICT is_set)
++{
++ unsigned start = 1;
++ unsigned end = 1 + ((*buf) >> 3);
++ unsigned dsize = end - start;
++
++ if (dsize < 17)
++ {
++ start = bm::sse2_gap_find(buf+1, (bm::gap_word_t)pos, dsize);
++ *is_set = ((*buf) & 1) ^ (start & 1);
++ BM_ASSERT(buf[start+1] >= pos);
++ BM_ASSERT(buf[start] < pos || (start==0));
++
++ return start+1;
++ }
++ unsigned arr_end = end;
++ while (start != end)
++ {
++ unsigned curr = (start + end) >> 1;
++ if (buf[curr] < pos)
++ start = curr + 1;
++ else
++ end = curr;
++
++ unsigned size = end - start;
++ if (size < 16)
++ {
++ size += (end != arr_end);
++ unsigned idx =
++ bm::sse2_gap_find(buf + start, (bm::gap_word_t)pos, size);
++ start += idx;
++
++ BM_ASSERT(buf[start] >= pos);
++ BM_ASSERT(buf[start - 1] < pos || (start == 1));
++ break;
++ }
++ }
++
++ *is_set = ((*buf) & 1) ^ ((start-1) & 1);
++ return start;
++}
++
++/**
++ Hybrid binary search, starts as binary, then switches to scan
++ @ingroup SSE2
++*/
++inline
++unsigned sse2_gap_test(const unsigned short* BMRESTRICT buf, unsigned pos)
++{
++ unsigned is_set;
++ bm::sse2_gap_bfind(buf, pos, &is_set);
++ return is_set;
++}
++
++
+ #ifdef __GNUG__
+ #pragma GCC diagnostic pop
+ #endif
+@@ -460,6 +528,8 @@
+ #define VECT_SET_BLOCK(dst, value) \
+ sse2_set_block((__m128i*) dst, value)
+
++#define VECT_GAP_BFIND(buf, pos, is_set) \
++ sse2_gap_bfind(buf, pos, is_set)
+
+
+ } // namespace
+Index: c++/include/util/bitset/bmblocks.h
+===================================================================
+--- a/c++/include/util/bitset/bmblocks.h (revision 90103)
++++ b/c++/include/util/bitset/bmblocks.h (revision 90104)
+@@ -59,10 +59,10 @@
+ public:
+ typedef id_type size_type;
+
+- bm_func_base(blocks_manager& bman) : bm_(bman) {}
++ bm_func_base(blocks_manager& bman) BMNOEXCEPT : bm_(bman) {}
+
+- void on_empty_top(unsigned /* top_block_idx*/ ) {}
+- void on_empty_block(block_idx_type /* block_idx*/ ) {}
++ void on_empty_top(unsigned /* top_block_idx*/ ) BMNOEXCEPT {}
++ void on_empty_block(block_idx_type /* block_idx*/ )BMNOEXCEPT {}
+ private:
+ bm_func_base(const bm_func_base&);
+ bm_func_base& operator=(const bm_func_base&);
+@@ -76,13 +76,13 @@
+ {
+ public:
+ typedef id_type size_type;
+- bm_func_base_const(const blocks_manager& bman) : bm_(bman) {}
++ bm_func_base_const(const blocks_manager& bman) BMNOEXCEPT : bm_(bman) {}
+
+- void on_empty_top(unsigned /* top_block_idx*/ ) {}
+- void on_empty_block(block_idx_type /* block_idx*/ ) {}
++ void on_empty_top(unsigned /* top_block_idx*/ ) BMNOEXCEPT {}
++ void on_empty_block(block_idx_type /* block_idx*/ ) BMNOEXCEPT {}
+ private:
+- bm_func_base_const(const bm_func_base_const&);
+- bm_func_base_const& operator=(const bm_func_base_const&);
++ bm_func_base_const(const bm_func_base_const&) BMNOEXCEPT;
++ bm_func_base_const& operator=(const bm_func_base_const&) BMNOEXCEPT;
+ protected:
+ const blocks_manager& bm_;
+ };
+@@ -92,10 +92,10 @@
+ class block_count_base : public bm_func_base_const
+ {
+ protected:
+- block_count_base(const blocks_manager& bm)
++ block_count_base(const blocks_manager& bm) BMNOEXCEPT
+ : bm_func_base_const(bm) {}
+
+- bm::id_t block_count(const bm::word_t* block) const
++ bm::id_t block_count(const bm::word_t* block) const BMNOEXCEPT
+ {
+ return this->bm_.block_bitcount(block);
+ }
+@@ -108,17 +108,17 @@
+ public:
+ typedef id_type size_type;
+
+- block_count_func(const blocks_manager& bm)
++ block_count_func(const blocks_manager& bm) BMNOEXCEPT
+ : block_count_base(bm), count_(0) {}
+
+- id_type count() const { return count_; }
++ id_type count() const BMNOEXCEPT { return count_; }
+
+- void operator()(const bm::word_t* block)
++ void operator()(const bm::word_t* block) BMNOEXCEPT
+ {
+ count_ += this->block_count(block);
+ }
+- void add_full(id_type c) { count_ += c; }
+- void reset() { count_ = 0; }
++ void add_full(id_type c) BMNOEXCEPT { count_ += c; }
++ void reset() BMNOEXCEPT { count_ = 0; }
+
+ private:
+ id_type count_;
+@@ -131,24 +131,22 @@
+ public:
+ typedef id_type size_type;
+
+- block_count_arr_func(const blocks_manager& bm, unsigned* arr)
++ block_count_arr_func(const blocks_manager& bm, unsigned* arr) BMNOEXCEPT
+ : block_count_base(bm), arr_(arr), last_idx_(0)
+ {
+ arr_[0] = 0;
+ }
+
+- void operator()(const bm::word_t* block, id_type idx)
++ void operator()(const bm::word_t* block, id_type idx) BMNOEXCEPT
+ {
+ while (++last_idx_ < idx)
+- {
+ arr_[last_idx_] = 0;
+- }
+ arr_[idx] = this->block_count(block);
+ last_idx_ = idx;
+ }
+
+- id_type last_block() const { return last_idx_; }
+- void on_non_empty_top(unsigned) {}
++ id_type last_block() const BMNOEXCEPT { return last_idx_; }
++ void on_non_empty_top(unsigned) BMNOEXCEPT {}
+
+ private:
+ unsigned* arr_;
+@@ -161,13 +159,14 @@
+ public:
+ typedef id_type size_type;
+
+- block_count_change_func(const blocks_manager& bm)
++ block_count_change_func(const blocks_manager& bm) BMNOEXCEPT
+ : bm_func_base_const(bm),
+ count_(0),
+ prev_block_border_bit_(0)
+ {}
+
+- block_idx_type block_count(const bm::word_t* block, block_idx_type idx)
++ block_idx_type block_count(const bm::word_t* block,
++ block_idx_type idx) BMNOEXCEPT
+ {
+ block_idx_type cnt = 0;
+ id_type first_bit;
+@@ -187,7 +186,7 @@
+ if (BM_IS_GAP(block))
+ {
+ gap_word_t* gap_block = BMGAP_PTR(block);
+- cnt = gap_length(gap_block) - 1;
++ cnt = bm::gap_length(gap_block) - 1;
+ if (idx)
+ {
+ first_bit = bm::gap_test_unr(gap_block, 0);
+@@ -213,9 +212,9 @@
+ return cnt;
+ }
+
+- id_type count() const { return count_; }
++ id_type count() const BMNOEXCEPT { return count_; }
+
+- void operator()(const bm::word_t* block, block_idx_type idx)
++ void operator()(const bm::word_t* block, block_idx_type idx) BMNOEXCEPT
+ {
+ count_ += block_count(block, idx);
+ }
+@@ -232,11 +231,12 @@
+ public:
+ typedef id_type size_type;
+
+- block_any_func(const blocks_manager& bm)
++ block_any_func(const blocks_manager& bm) BMNOEXCEPT
+ : bm_func_base_const(bm)
+ {}
+
+- bool operator()(const bm::word_t* block, block_idx_type /*idx*/)
++ bool operator()
++ (const bm::word_t* block, block_idx_type /*idx*/) BMNOEXCEPT
+ {
+ if (BM_IS_GAP(block)) // gap block
+ return (!gap_is_all_zero(BMGAP_PTR(block)));
+@@ -250,9 +250,9 @@
+ class gap_level_func : public bm_func_base
+ {
+ public:
+- gap_level_func(blocks_manager& bm, const gap_word_t* glevel_len)
+- : bm_func_base(bm),
+- glevel_len_(glevel_len)
++ gap_level_func(blocks_manager& bm,
++ const gap_word_t* glevel_len) BMNOEXCEPT
++ : bm_func_base(bm), glevel_len_(glevel_len)
+ {
+ BM_ASSERT(glevel_len);
+ }
+@@ -282,12 +282,11 @@
+ return;
+ }
+
+- unsigned len = gap_length(gap_blk);
+- int level = gap_calc_level(len, glevel_len_);
++ unsigned len = bm::gap_length(gap_blk);
++ int level = bm::gap_calc_level(len, glevel_len_);
+ if (level == -1)
+ {
+- bm::word_t* blk =
+- bman.get_allocator().alloc_bit_block();
++ bm::word_t* blk = bman.get_allocator().alloc_bit_block();
+ bman.set_block_ptr(idx, blk);
+ bm::gap_convert_to_bitset(blk, gap_blk);
+ }
+@@ -294,7 +293,7 @@
+ else
+ {
+ gap_word_t* gap_blk_new =
+- bman.allocate_gap_block(unsigned(level), gap_blk, glevel_len_);
++ bman.allocate_gap_block(unsigned(level), gap_blk, glevel_len_);
+
+ bm::word_t* p = (bm::word_t*) gap_blk_new;
+ BMSET_PTRGAP(p);
+@@ -312,7 +311,7 @@
+ class block_one_func : public bm_func_base
+ {
+ public:
+- block_one_func(blocks_manager& bm) : bm_func_base(bm) {}
++ block_one_func(blocks_manager& bm) BMNOEXCEPT : bm_func_base(bm) {}
+
+ void operator()(bm::word_t* block, block_idx_type idx)
+ {
+@@ -357,7 +356,7 @@
+ }
+
+ #ifndef BM_NO_CXX11
+- blocks_manager(blocks_manager&& blockman) BMNOEXEPT
++ blocks_manager(blocks_manager&& blockman) BMNOEXCEPT
+ : max_bits_(blockman.max_bits_),
+ top_blocks_(0),
+ top_block_size_(blockman.top_block_size_),
+@@ -369,7 +368,7 @@
+ }
+ #endif
+
+- ~blocks_manager() BMNOEXEPT
++ ~blocks_manager() BMNOEXCEPT
+ {
+ if (temp_block_)
+ alloc_.free_bit_block(temp_block_);
+@@ -379,7 +378,7 @@
+ /*! \brief Swaps content
+ \param bm another blocks manager
+ */
+- void swap(blocks_manager& bm) BMNOEXEPT
++ void swap(blocks_manager& bm) BMNOEXCEPT
+ {
+ BM_ASSERT(this != &bm);
+
+@@ -399,7 +398,7 @@
+
+ /*! \brief implementation of moving semantics
+ */
+- void move_from(blocks_manager& bm) BMNOEXEPT
++ void move_from(blocks_manager& bm) BMNOEXCEPT
+ {
+ deinit_tree();
+ swap(bm);
+@@ -412,9 +411,9 @@
+ }
+
+
+- void free_ptr(bm::word_t** ptr)
++ void free_ptr(bm::word_t** ptr) BMNOEXCEPT
+ {
+- if (ptr) alloc_.free_ptr(ptr);
++ alloc_.free_ptr(ptr);
+ }
+
+ /**
+@@ -422,7 +421,7 @@
+ \param bits_to_store - supposed capacity (number of bits)
+ \return size of the top level block
+ */
+- unsigned compute_top_block_size(id_type bits_to_store)
++ unsigned compute_top_block_size(id_type bits_to_store) const BMNOEXCEPT
+ {
+ if (bits_to_store >= bm::id_max) // working in full-range mode
+ return bm::set_top_array_size;
+@@ -456,7 +455,8 @@
+ \param no_more_blocks - 1 if there are no more blocks at all
+ \return block adress or NULL if not yet allocated
+ */
+- bm::word_t* get_block(block_idx_type nb, int* no_more_blocks) const
++ const bm::word_t*
++ get_block(block_idx_type nb, int* no_more_blocks) const BMNOEXCEPT
+ {
+ BM_ASSERT(top_blocks_);
+ unsigned i = unsigned(nb >> bm::set_array_shift);
+@@ -489,7 +489,7 @@
+ @return bm::set_total_blocks - no more blocks
+ */
+ block_idx_type
+- find_next_nz_block(block_idx_type nb, bool deep_scan = true) const
++ find_next_nz_block(block_idx_type nb, bool deep_scan=true) const BMNOEXCEPT
+ {
+ if (is_init())
+ {
+@@ -521,7 +521,7 @@
+ \param j - second level block index
+ \return block adress or NULL if not yet allocated
+ */
+- const bm::word_t* get_block(unsigned i, unsigned j) const
++ const bm::word_t* get_block(unsigned i, unsigned j) const BMNOEXCEPT
+ {
+ if (!top_blocks_ || i >= top_block_size_) return 0;
+ const bm::word_t* const* blk_blk = top_blocks_[i];
+@@ -537,7 +537,7 @@
+ \param j - second level block index
+ \return block adress or NULL if not yet allocated
+ */
+- const bm::word_t* get_block_ptr(unsigned i, unsigned j) const
++ const bm::word_t* get_block_ptr(unsigned i, unsigned j) const BMNOEXCEPT
+ {
+ if (!top_blocks_ || i >= top_block_size_) return 0;
+
+@@ -553,9 +553,10 @@
+ \param j - second level block index
+ \return block adress or NULL if not yet allocated
+ */
+- bm::word_t* get_block_ptr(unsigned i, unsigned j)
++ bm::word_t* get_block_ptr(unsigned i, unsigned j) BMNOEXCEPT
+ {
+- if (!top_blocks_ || i >= top_block_size_) return 0;
++ if (!top_blocks_ || i >= top_block_size_)
++ return 0;
+ bm::word_t* const* blk_blk = top_blocks_[i];
+ if ((bm::word_t*)blk_blk == FULL_BLOCK_FAKE_ADDR)
+ return FULL_BLOCK_FAKE_ADDR;
+@@ -569,7 +570,7 @@
+ \param i - top level block index
+ \return block adress or NULL if not yet allocated
+ */
+- const bm::word_t* const * get_topblock(unsigned i) const
++ const bm::word_t* const * get_topblock(unsigned i) const BMNOEXCEPT
+ {
+ return (!top_blocks_ || i >= top_block_size_) ? 0 : top_blocks_[i];
+ }
+@@ -577,7 +578,7 @@
+ /**
+ \brief Returns root block in the tree.
+ */
+- bm::word_t*** top_blocks_root() const
++ bm::word_t*** top_blocks_root() const BMNOEXCEPT
+ {
+ blocks_manager* bm =
+ const_cast<blocks_manager*>(this);
+@@ -837,7 +838,7 @@
+ {
+ gap_res = true;
+ new_block = (bm::word_t*)
+- get_allocator().alloc_gap_block(unsigned(new_level), glen());
++ get_allocator().alloc_gap_block(unsigned(new_level), glen());
+ ::memcpy(new_block, gap_block, len * sizeof(bm::gap_word_t));
+ bm::set_gap_level(new_block, new_level);
+ }
+@@ -1124,7 +1125,7 @@
+ /*! @brief Fills all blocks with 0.
+ @param free_mem - if true function frees the resources (obsolete)
+ */
+- void set_all_zero(bool /*free_mem*/)
++ void set_all_zero(bool /*free_mem*/) BMNOEXCEPT
+ {
+ if (!is_init()) return;
+ deinit_tree(); // TODO: optimization of top-level realloc
+@@ -1141,7 +1142,7 @@
+ bm::set_sub_array_size, func);
+ }
+
+- void free_top_subblock(unsigned nblk_blk)
++ void free_top_subblock(unsigned nblk_blk) BMNOEXCEPT
+ {
+ BM_ASSERT(top_blocks_[nblk_blk]);
+ if ((bm::word_t*)top_blocks_[nblk_blk] != FULL_BLOCK_FAKE_ADDR)
+@@ -1452,7 +1453,7 @@
+ Places new block into blocks table.
+ */
+ BMFORCEINLINE
+- void set_block_ptr(unsigned i, unsigned j, bm::word_t* block)
++ void set_block_ptr(unsigned i, unsigned j, bm::word_t* block) BMNOEXCEPT
+ {
+ BM_ASSERT(is_init());
+ BM_ASSERT(i < top_block_size_);
+@@ -1597,7 +1598,7 @@
+ /**
+ Free block, make it zero pointer in the tree
+ */
+- void zero_gap_block_ptr(unsigned i, unsigned j)
++ void zero_gap_block_ptr(unsigned i, unsigned j) BMNOEXCEPT
+ {
+ BM_ASSERT(top_blocks_ && i < top_block_size_);
+
+@@ -1616,19 +1617,15 @@
+ Count number of bits ON in the block
+ */
+ static
+- bm::id_t block_bitcount(const bm::word_t* block)
++ bm::id_t block_bitcount(const bm::word_t* block) BMNOEXCEPT
+ {
+ BM_ASSERT(block);
+ id_t count;
+ if (BM_IS_GAP(block))
+- {
+ count = bm::gap_bit_count_unr(BMGAP_PTR(block));
+- }
+ else // bitset
+- {
+ count = (IS_FULL_BLOCK(block)) ? bm::bits_in_block
+ : bm::bit_block_count(block);
+- }
+ return count;
+ }
+
+@@ -1678,7 +1675,7 @@
+ }
+
+ /*! deallocate temp block */
+- void free_temp_block()
++ void free_temp_block() BMNOEXCEPT
+ {
+ if (temp_block_)
+ {
+@@ -1686,6 +1683,7 @@
+ temp_block_ = 0;
+ }
+ }
++
+ /*! Detach and return temp block.
+ if temp block is NULL allocates a bit-block
+ caller is responsible for returning
+@@ -1705,7 +1703,7 @@
+ /*! Return temp block
+ if temp block already exists - block gets deallocated
+ */
+- void return_tempblock(bm::word_t* block)
++ void return_tempblock(bm::word_t* block) BMNOEXCEPT
+ {
+ BM_ASSERT(block != temp_block_);
+ BM_ASSERT(IS_VALID_ADDR(block));
+@@ -1717,7 +1715,7 @@
+ }
+
+ /*! Assigns new GAP lengths vector */
+- void set_glen(const gap_word_t* glevel_len)
++ void set_glen(const gap_word_t* glevel_len) BMNOEXCEPT
+ {
+ ::memcpy(glevel_len_, glevel_len, sizeof(glevel_len_));
+ }
+@@ -1745,7 +1743,7 @@
+
+ /** Returns true if second level block pointer is 0.
+ */
+- bool is_subblock_null(unsigned nsub) const
++ bool is_subblock_null(unsigned nsub) const BMNOEXCEPT
+ {
+ BM_ASSERT(top_blocks_);
+ if (nsub >= top_block_size_)
+@@ -1753,7 +1751,7 @@
+ return top_blocks_[nsub] == NULL;
+ }
+
+- bm::word_t*** top_blocks_root()
++ bm::word_t*** top_blocks_root() BMNOEXCEPT
+ {
+ return top_blocks_;
+ }
+@@ -1760,7 +1758,7 @@
+
+ /*! \brief Returns current GAP level vector
+ */
+- const gap_word_t* glen() const
++ const gap_word_t* glen() const BMNOEXCEPT
+ {
+ return glevel_len_;
+ }
+@@ -1768,7 +1766,7 @@
+ /*! \brief Returns GAP level length for specified level
+ \param level - level number
+ */
+- unsigned glen(unsigned level) const
++ unsigned glen(unsigned level) const BMNOEXCEPT
+ {
+ return glevel_len_[level];
+ }
+@@ -1775,7 +1773,7 @@
+
+ /*! \brief Returns size of the top block array in the tree
+ */
+- unsigned top_block_size() const
++ unsigned top_block_size() const BMNOEXCEPT
+ {
+ return top_block_size_;
+ }
+@@ -1829,21 +1827,20 @@
+
+ /** \brief Returns reference on the allocator
+ */
+- allocator_type& get_allocator() { return alloc_; }
++ allocator_type& get_allocator() BMNOEXCEPT { return alloc_; }
+
+ /** \brief Returns allocator
+ */
+- allocator_type get_allocator() const { return alloc_; }
++ allocator_type get_allocator() const BMNOEXCEPT { return alloc_; }
+
+
+ /// if tree of blocks already up
+- bool is_init() const { return top_blocks_ != 0; }
++ bool is_init() const BMNOEXCEPT { return top_blocks_ != 0; }
+
+ /// allocate first level of descr. of blocks
+ void init_tree()
+ {
+ BM_ASSERT(top_blocks_ == 0);
+-
+ if (top_block_size_)
+ {
+ top_blocks_ = (bm::word_t***) alloc_.alloc_ptr(top_block_size_);
+@@ -1865,7 +1862,7 @@
+ alloc_.free_bit_block(blk); \
+ }
+
+- void deallocate_top_subblock(unsigned nblk_blk)
++ void deallocate_top_subblock(unsigned nblk_blk) BMNOEXCEPT
+ {
+ if (!top_blocks_[nblk_blk])
+ return;
+@@ -1907,7 +1904,7 @@
+ /** destroy tree, free memory in all blocks and control structures
+ Note: pointers are NOT assigned to zero(!)
+ */
+- void destroy_tree() BMNOEXEPT
++ void destroy_tree() BMNOEXCEPT
+ {
+ if (!top_blocks_)
+ return;
+@@ -1937,7 +1934,7 @@
+ }
+ #undef BM_FREE_OP
+
+- void deinit_tree() BMNOEXEPT
++ void deinit_tree() BMNOEXCEPT
+ {
+ destroy_tree();
+ top_blocks_ = 0; top_block_size_ = 0;
+@@ -1946,7 +1943,7 @@
+ // ----------------------------------------------------------------
+
+ /// calculate top blocks which are not NULL and not FULL
+- unsigned find_real_top_blocks() const
++ unsigned find_real_top_blocks() const BMNOEXCEPT
+ {
+ unsigned cnt = 0;
+ unsigned top_blocks = top_block_size();
+@@ -1964,7 +1961,7 @@
+ // ----------------------------------------------------------------
+
+ /// calculate max top blocks size whithout NULL-tail
+- unsigned find_max_top_blocks() const
++ unsigned find_max_top_blocks() const BMNOEXCEPT
+ {
+ unsigned top_blocks = top_block_size();
+ if (!top_blocks)
+@@ -1981,11 +1978,11 @@
+
+ // ----------------------------------------------------------------
+
+- void validate_top_zero(unsigned i)
++ void validate_top_zero(unsigned i) BMNOEXCEPT
+ {
+ BM_ASSERT(i < top_block_size());
+ bm::word_t** blk_blk = top_blocks_[i];
+- // TODO: SIMD
++ // TODO: SIMD or unroll
+ for (unsigned j = 0; j < bm::set_sub_array_size; ++j)
+ {
+ if (blk_blk[j])
+@@ -1997,7 +1994,7 @@
+
+ // ----------------------------------------------------------------
+
+- void validate_top_full(unsigned i)
++ void validate_top_full(unsigned i) BMNOEXCEPT
+ {
+ BM_ASSERT(i < top_block_size());
+ bm::word_t** blk_blk = top_blocks_[i];
+@@ -2015,7 +2012,7 @@
+ Calculate approximate memory needed to serialize big runs
+ of 0000s and 111s (as blocks)
+ */
+- size_t calc_serialization_null_full() const
++ size_t calc_serialization_null_full() const BMNOEXCEPT
+ {
+ size_t s_size = sizeof(unsigned);
+ if (!top_blocks_)
+@@ -2041,6 +2038,9 @@
+ }
+ nb_empty += (i - nb_prev) * bm::set_sub_array_size;
+ blk_blk = top_blocks_[i];
++ BM_ASSERT(blk_blk);
++ if (!blk_blk)
++ break;
+ }
+ if ((bm::word_t*)blk_blk == FULL_BLOCK_FAKE_ADDR)
+ {
+@@ -2357,7 +2357,7 @@
+ class bit_block_guard
+ {
+ public:
+- bit_block_guard(BlocksManager& bman, bm::word_t* blk=0)
++ bit_block_guard(BlocksManager& bman, bm::word_t* blk=0) BMNOEXCEPT
+ : bman_(bman),
+ block_(blk)
+ {}
+@@ -2366,18 +2366,20 @@
+ if (IS_VALID_ADDR(block_))
+ bman_.get_allocator().free_bit_block(block_, 3);
+ }
+- void attach(bm::word_t* blk)
++
++ void attach(bm::word_t* blk) BMNOEXCEPT
+ {
+ if (IS_VALID_ADDR(block_))
+ bman_.get_allocator().free_bit_block(block_);
+ block_ = blk;
+ }
++
+ bm::word_t* allocate()
+ {
+ attach(bman_.get_allocator().alloc_bit_block(3));
+ return block_;
+ }
+- bm::word_t* get() { return block_; }
++ bm::word_t* get() BMNOEXCEPT { return block_; }
+
+ private:
+ bit_block_guard(const bit_block_guard&);
+Index: c++/include/util/bitset/bmutil.h
+===================================================================
+--- a/c++/include/util/bitset/bmutil.h (revision 90103)
++++ b/c++/include/util/bitset/bmutil.h (revision 90104)
+@@ -94,22 +94,34 @@
+ bm::word_t* end() { return (b_.w32 + bm::set_block_size); }
+ };
+
+-
+ /**
+ Get minimum of 2 values
+ */
+ template<typename T>
+-T min_value(T v1, T v2)
++T min_value(T v1, T v2) BMNOEXCEPT
+ {
+ return v1 < v2 ? v1 : v2;
+ }
+
++/**
++ \brief ad-hoc conditional expressions
++ \internal
++*/
++template <bool b> struct conditional
++{
++ static bool test() { return true; }
++};
++template <> struct conditional<false>
++{
++ static bool test() { return false; }
++};
+
++
+ /**
+ Fast loop-less function to find LOG2
+ */
+ template<typename T>
+-T ilog2(T x)
++T ilog2(T x) BMNOEXCEPT
+ {
+ unsigned int l = 0;
+
+@@ -122,7 +134,7 @@
+ }
+
+ template<>
+-inline bm::gap_word_t ilog2(gap_word_t x)
++inline bm::gap_word_t ilog2(gap_word_t x) BMNOEXCEPT
+ {
+ unsigned int l = 0;
+ if (x >= 1<<8) { x = (bm::gap_word_t)(x >> 8); l |= 8; }
+@@ -140,7 +152,7 @@
+ class ptr_guard
+ {
+ public:
+- ptr_guard(T* p) : ptr_(p) {}
++ ptr_guard(T* p) BMNOEXCEPT : ptr_(p) {}
+ ~ptr_guard() { delete ptr_; }
+ private:
+ ptr_guard(const ptr_guard<T>& p);
+@@ -154,8 +166,7 @@
+ @ingroup bitfunc
+ @internal
+ */
+-inline
+-unsigned count_leading_zeros(unsigned x)
++inline unsigned count_leading_zeros(unsigned x) BMNOEXCEPT
+ {
+ unsigned n =
+ (x >= (1U << 16)) ?
+@@ -171,7 +182,7 @@
+ @internal
+ */
+ inline
+-unsigned count_trailing_zeros(unsigned v)
++unsigned count_trailing_zeros(unsigned v) BMNOEXCEPT
+ {
+ // (v & -v) isolates the last set bit
+ return unsigned(bm::tzcnt_table<true>::_lut[(-v & v) % 37]);
+@@ -181,7 +192,7 @@
+ Lookup table based integer LOG2
+ */
+ template<typename T>
+-T ilog2_LUT(T x)
++T ilog2_LUT(T x) BMNOEXCEPT
+ {
+ unsigned l = 0;
+ if (x & 0xffff0000)
+@@ -200,7 +211,7 @@
+ Lookup table based short integer LOG2
+ */
+ template<>
+-inline bm::gap_word_t ilog2_LUT<bm::gap_word_t>(bm::gap_word_t x)
++inline bm::gap_word_t ilog2_LUT<bm::gap_word_t>(bm::gap_word_t x) BMNOEXCEPT
+ {
+ bm::gap_word_t l = 0;
+ if (x & 0xff00)
+@@ -218,7 +229,7 @@
+ #ifdef __GNUG__
+
+ BMFORCEINLINE
+-unsigned bsf_asm32(unsigned int v)
++unsigned bsf_asm32(unsigned int v) BMNOEXCEPT
+ {
+ unsigned r;
+ asm volatile(" bsfl %1, %0": "=r"(r): "rm"(v) );
+@@ -226,7 +237,7 @@
+ }
+
+ BMFORCEINLINE
+-unsigned bsr_asm32(unsigned int v)
++unsigned bsr_asm32(unsigned int v) BMNOEXCEPT
+ {
+ unsigned r;
+ asm volatile(" bsrl %1, %0": "=r"(r): "rm"(v) );
+@@ -240,7 +251,7 @@
+ #if defined(_M_AMD64) || defined(_M_X64) // inline assembly not supported
+
+ BMFORCEINLINE
+-unsigned int bsr_asm32(unsigned int value)
++unsigned int bsr_asm32(unsigned int value) BMNOEXCEPT
+ {
+ unsigned long r;
+ _BitScanReverse(&r, value);
+@@ -248,7 +259,7 @@
+ }
+
+ BMFORCEINLINE
+-unsigned int bsf_asm32(unsigned int value)
++unsigned int bsf_asm32(unsigned int value) BMNOEXCEPT
+ {
+ unsigned long r;
+ _BitScanForward(&r, value);
+@@ -258,13 +269,13 @@
+ #else
+
+ BMFORCEINLINE
+-unsigned int bsr_asm32(unsigned int value)
++unsigned int bsr_asm32(unsigned int value) BMNOEXCEPT
+ {
+ __asm bsr eax, value
+ }
+
+ BMFORCEINLINE
+-unsigned int bsf_asm32(unsigned int value)
++unsigned int bsf_asm32(unsigned int value) BMNOEXCEPT
+ {
+ __asm bsf eax, value
+ }
+@@ -280,7 +291,7 @@
+ // http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.37.8562
+ //
+ template<typename T>
+-T bit_scan_fwd(T v)
++T bit_scan_fwd(T v) BMNOEXCEPT
+ {
+ return
+ DeBruijn_bit_position<true>::_multiply[(((v & -v) * 0x077CB531U)) >> 27];
+@@ -287,7 +298,7 @@
+ }
+
+ inline
+-unsigned bit_scan_reverse32(unsigned value)
++unsigned bit_scan_reverse32(unsigned value) BMNOEXCEPT
+ {
+ BM_ASSERT(value);
+ #if defined(BM_USE_GCC_BUILD)
+@@ -302,7 +313,7 @@
+ }
+
+ inline
+-unsigned bit_scan_forward32(unsigned value)
++unsigned bit_scan_forward32(unsigned value) BMNOEXCEPT
+ {
+ BM_ASSERT(value);
+ #if defined(BM_USE_GCC_BUILD)
+@@ -318,7 +329,7 @@
+
+
+ BMFORCEINLINE
+-unsigned long long bmi_bslr_u64(unsigned long long w)
++unsigned long long bmi_bslr_u64(unsigned long long w) BMNOEXCEPT
+ {
+ #if defined(BMAVX2OPT) || defined (BMAVX512OPT)
+ return _blsr_u64(w);
+@@ -339,7 +350,7 @@
+
+ /// 64-bit bit-scan reverse
+ inline
+-unsigned count_leading_zeros_u64(bm::id64_t w)
++unsigned count_leading_zeros_u64(bm::id64_t w) BMNOEXCEPT
+ {
+ BM_ASSERT(w);
+ #if defined(BMAVX2OPT) || defined (BMAVX512OPT)
+@@ -367,7 +378,7 @@
+
+ /// 64-bit bit-scan fwd
+ inline
+-unsigned count_trailing_zeros_u64(bm::id64_t w)
++unsigned count_trailing_zeros_u64(bm::id64_t w) BMNOEXCEPT
+ {
+ BM_ASSERT(w);
+
+@@ -396,6 +407,72 @@
+
+
+
++/*!
++ Returns BSR value
++ @ingroup bitfunc
++*/
++template <class T>
++unsigned bit_scan_reverse(T value) BMNOEXCEPT
++{
++ BM_ASSERT(value);
++
++ if (bm::conditional<sizeof(T)==8>::test())
++ {
++ #if defined(BM_USE_GCC_BUILD)
++ return (unsigned) (63 - __builtin_clzll(value));
++ #else
++ bm::id64_t v8 = value;
++ v8 >>= 32;
++ unsigned v = (unsigned)v8;
++ if (v)
++ {
++ v = bm::bit_scan_reverse32(v);
++ return v + 32;
++ }
++ #endif
++ }
++ return bm::bit_scan_reverse32((unsigned)value);
++}
++
++/*! \brief and functor
++ \internal
++ */
++struct and_func
++{
++ static
++ BMFORCEINLINE unsigned op(unsigned v1, unsigned v2) BMNOEXCEPT2
++ { return v1 & v2; }
++};
++/*! \brief xor functor
++ \internal
++ */
++struct xor_func
++{
++ static
++ BMFORCEINLINE unsigned op(unsigned v1, unsigned v2) BMNOEXCEPT2
++ { return v1 ^ v2; }
++};
++/*! \brief or functor
++ \internal
++ */
++struct or_func
++{
++ static
++ BMFORCEINLINE unsigned op(unsigned v1, unsigned v2) BMNOEXCEPT2
++ { return v1 | v2; }
++};
++/*! \brief sub functor
++ \internal
++ */
++struct sub_func
++{
++ static
++ BMFORCEINLINE unsigned op(unsigned v1, unsigned v2) BMNOEXCEPT2
++ { return v1 & ~v2; }
++};
++
++
++
+ #ifdef __GNUG__
+ #pragma GCC diagnostic pop
+ #endif
+Index: c++/include/util/bitset/bmsse4.h
+===================================================================
+--- a/c++/include/util/bitset/bmsse4.h (revision 90103)
++++ b/c++/include/util/bitset/bmsse4.h (revision 90104)
+@@ -577,6 +577,17 @@
+ }
+
+ /*!
++ @brief check if SSE wave is all oxFFFF...FFF
++ @ingroup SSE4
++*/
++BMFORCEINLINE
++bool sse42_test_all_one_wave(const void* ptr)
++{
++ return _mm_test_all_ones(_mm_loadu_si128((__m128i*)ptr));
++}
++
++
++/*!
+ @brief check if wave of pointers is all NULL
+ @ingroup SSE4
+ */
+@@ -973,12 +984,14 @@
+ #endif
+
+ /*!
+- SSE4.2 check for one to two (variable len) 128 bit SSE lines for gap search results (8 elements)
++ SSE4.2 check for one to two (variable len) 128 bit SSE lines
++ for gap search results (8 elements)
+ @ingroup SSE4
+ \internal
+ */
+ inline
+-unsigned sse4_gap_find(const bm::gap_word_t* BMRESTRICT pbuf, const bm::gap_word_t pos, const unsigned size)
++unsigned sse4_gap_find(const bm::gap_word_t* BMRESTRICT pbuf,
++ const bm::gap_word_t pos, const unsigned size)
+ {
+ BM_ASSERT(size <= 16);
+ BM_ASSERT(size);
+@@ -1032,6 +1045,74 @@
+ }
+
+ /**
++ Hybrid binary search, starts as binary, then switches to linear scan
++
++ \param buf - GAP buffer pointer.
++ \param pos - index of the element.
++ \param is_set - output. GAP value (0 or 1).
++ \return GAP index.
++
++ @ingroup SSE4
++*/
++inline
++unsigned sse42_gap_bfind(const unsigned short* BMRESTRICT buf,
++ unsigned pos, unsigned* BMRESTRICT is_set)
++{
++ unsigned start = 1;
++ unsigned end = 1 + ((*buf) >> 3);
++ unsigned dsize = end - start;
++
++ if (dsize < 17)
++ {
++ start = bm::sse4_gap_find(buf+1, (bm::gap_word_t)pos, dsize);
++ *is_set = ((*buf) & 1) ^ (start & 1);
++ BM_ASSERT(buf[start+1] >= pos);
++ BM_ASSERT(buf[start] < pos || (start==0));
++
++ return start+1;
++ }
++ unsigned arr_end = end;
++ while (start != end)
++ {
++ unsigned curr = (start + end) >> 1;
++ if (buf[curr] < pos)
++ start = curr + 1;
++ else
++ end = curr;
++
++ unsigned size = end - start;
++ if (size < 16)
++ {
++ size += (end != arr_end);
++ unsigned idx =
++ bm::sse4_gap_find(buf + start, (bm::gap_word_t)pos, size);
++ start += idx;
++
++ BM_ASSERT(buf[start] >= pos);
++ BM_ASSERT(buf[start - 1] < pos || (start == 1));
++ break;
++ }
++ }
++
++ *is_set = ((*buf) & 1) ^ ((start-1) & 1);
++ return start;
++}
++
++/**
++ Hybrid binary search, starts as binary, then switches to scan
++ @ingroup SSE4
++*/
++inline
++unsigned sse42_gap_test(const unsigned short* BMRESTRICT buf, unsigned pos)
++{
++ unsigned is_set;
++ bm::sse42_gap_bfind(buf, pos, &is_set);
++ return is_set;
++}
++
++
++
++/**
+ Experimental (test) function to do SIMD vector search (lower bound)
+ in sorted, growing array
+ @ingroup SSE4
+@@ -1751,6 +1832,8 @@
+ #define VECT_BIT_BLOCK_XOR(t, src, src_xor, d) \
+ sse42_bit_block_xor(t, src, src_xor, d)
+
++#define VECT_GAP_BFIND(buf, pos, is_set) \
++ sse42_gap_bfind(buf, pos, is_set)
+
+ #ifdef __GNUG__
+ #pragma GCC diagnostic pop
+Index: c++/include/util/bitset/bmserial.h
+===================================================================
+--- a/c++/include/util/bitset/bmserial.h (revision 90103)
++++ b/c++/include/util/bitset/bmserial.h (revision 90104)
+@@ -75,12 +75,12 @@
+ class serializer
+ {
+ public:
+- typedef BV bvector_type;
+- typedef typename bvector_type::allocator_type allocator_type;
+- typedef typename bvector_type::blocks_manager_type blocks_manager_type;
+- typedef typename bvector_type::statistics statistics_type;
+- typedef typename bvector_type::block_idx_type block_idx_type;
+- typedef typename bvector_type::size_type size_type;
++ typedef BV bvector_type;
++ typedef typename bvector_type::allocator_type allocator_type;
++ typedef typename bvector_type::blocks_manager_type blocks_manager_type;
++ typedef typename bvector_type::statistics statistics_type;
++ typedef typename bvector_type::block_idx_type block_idx_type;
++ typedef typename bvector_type::size_type size_type;
+
+ typedef byte_buffer<allocator_type> buffer;
+ typedef bm::bv_ref_vector<BV> bv_ref_vector_type;
+@@ -113,7 +113,7 @@
+ @param clevel - compression level (0-5)
+ @sa get_compression_level
+ */
+- void set_compression_level(unsigned clevel);
++ void set_compression_level(unsigned clevel) BMNOEXCEPT;
+
+ /**
+ Get compression level (0-5), Default 5 (recommended)
+@@ -127,7 +127,8 @@
+ Recommended: use 3 or 5
+
+ */
+- unsigned get_compression_level() const { return compression_level_; }
++ unsigned get_compression_level() const BMNOEXCEPT
++ { return compression_level_; }
+
+
+ //@}
+@@ -189,7 +190,8 @@
+ Return serialization counter vector
+ @internal
+ */
+- const size_type* get_compression_stat() const { return compression_stat_; }
++ const size_type* get_compression_stat() const BMNOEXCEPT
++ { return compression_stat_; }
+
+ /**
+ Set GAP length serialization (serializes GAP levels of the original vector)
+@@ -196,13 +198,13 @@
+
+ @param value - when TRUE serialized vector includes GAP levels parameters
+ */
+- void gap_length_serialization(bool value);
++ void gap_length_serialization(bool value) BMNOEXCEPT;
+
+ /**
+ Set byte-order serialization (for cross platform compatibility)
+ @param value - TRUE serialization format includes byte-order marker
+ */
+- void byte_order_serialization(bool value);
++ void byte_order_serialization(bool value) BMNOEXCEPT;
+
+ /**
+ Add skip-markers to serialization BLOB for faster range decode
+@@ -214,7 +216,7 @@
+ smaller interval means more bookmarks added to the skip list thus
+ more increasing the BLOB size
+ */
+- void set_bookmarks(bool enable, unsigned bm_interval = 256);
++ void set_bookmarks(bool enable, unsigned bm_interval = 256) BMNOEXCEPT;
+
+ /**
+ Attach collection of reference vectors for XOR serialization
+@@ -227,7 +229,7 @@
+ Set current index in rer.vector collection
+ (not a row idx or plain idx)
+ */
+- void set_curr_ref_idx(size_type ref_idx);
++ void set_curr_ref_idx(size_type ref_idx) BMNOEXCEPT;
+
+
+ protected:
+@@ -234,13 +236,14 @@
+ /**
+ Encode serialization header information
+ */
+- void encode_header(const BV& bv, bm::encoder& enc);
++ void encode_header(const BV& bv, bm::encoder& enc) BMNOEXCEPT;
+
+ /*! Encode GAP block */
+ void encode_gap_block(const bm::gap_word_t* gap_block, bm::encoder& enc);
+
+ /*! Encode GAP block with Elias Gamma coder */
+- void gamma_gap_block(const bm::gap_word_t* gap_block, bm::encoder& enc);
++ void gamma_gap_block(const bm::gap_word_t* gap_block,
++ bm::encoder& enc) BMNOEXCEPT;
+
+ /**
+ Encode GAP block as delta-array with Elias Gamma coder
+@@ -248,29 +251,30 @@
+ void gamma_gap_array(const bm::gap_word_t* gap_block,
+ unsigned arr_len,
+ bm::encoder& enc,
+- bool inverted = false);
++ bool inverted = false) BMNOEXCEPT;
+
+ /// Encode bit-block as an array of bits
+ void encode_bit_array(const bm::word_t* block,
+- bm::encoder& enc, bool inverted);
++ bm::encoder& enc, bool inverted) BMNOEXCEPT;
+
+ void gamma_gap_bit_block(const bm::word_t* block,
+- bm::encoder& enc);
++ bm::encoder& enc) BMNOEXCEPT;
+
+ void gamma_arr_bit_block(const bm::word_t* block,
+- bm::encoder& enc, bool inverted);
++ bm::encoder& enc, bool inverted) BMNOEXCEPT;
+
+ void bienc_arr_bit_block(const bm::word_t* block,
+- bm::encoder& enc, bool inverted);
++ bm::encoder& enc, bool inverted) BMNOEXCEPT;
+
+ /// encode bit-block as interpolated bit block of gaps
+- void bienc_gap_bit_block(const bm::word_t* block, bm::encoder& enc);
++ void bienc_gap_bit_block(const bm::word_t* block,
++ bm::encoder& enc) BMNOEXCEPT;
+
+ void interpolated_arr_bit_block(const bm::word_t* block,
+- bm::encoder& enc, bool inverted);
++ bm::encoder& enc, bool inverted) BMNOEXCEPT;
+ /// encode bit-block as interpolated gap block
+ void interpolated_gap_bit_block(const bm::word_t* block,
+- bm::encoder& enc);
++ bm::encoder& enc) BMNOEXCEPT;
+
+ /**
+ Encode GAP block as an array with binary interpolated coder
+@@ -278,16 +282,16 @@
+ void interpolated_gap_array(const bm::gap_word_t* gap_block,
+ unsigned arr_len,
+ bm::encoder& enc,
+- bool inverted);
++ bool inverted) BMNOEXCEPT;
+ void interpolated_gap_array_v0(const bm::gap_word_t* gap_block,
+ unsigned arr_len,
+ bm::encoder& enc,
+- bool inverted);
++ bool inverted) BMNOEXCEPT;
+
+
+ /*! Encode GAP block with using binary interpolated encoder */
+ void interpolated_encode_gap_block(
+- const bm::gap_word_t* gap_block, bm::encoder& enc);
++ const bm::gap_word_t* gap_block, bm::encoder& enc) BMNOEXCEPT;
+
+ /**
+ Encode BIT block with repeatable runs of zeroes
+@@ -294,13 +298,13 @@
+ */
+ void encode_bit_interval(const bm::word_t* blk,
+ bm::encoder& enc,
+- unsigned size_control);
++ unsigned size_control) BMNOEXCEPT;
+ /**
+ Encode bit-block using digest (hierarchical compression)
+ */
+ void encode_bit_digest(const bm::word_t* blk,
+- bm::encoder& enc,
+- bm::id64_t d0);
++ bm::encoder& enc,
++ bm::id64_t d0) BMNOEXCEPT;
+
+ /**
+ Determine best representation for GAP block based
+@@ -314,25 +318,26 @@
+
+ @internal
+ */
+- unsigned char find_gap_best_encoding(const bm::gap_word_t* gap_block);
++ unsigned char
++ find_gap_best_encoding(const bm::gap_word_t* gap_block) BMNOEXCEPT;
+
+ /// Determine best representation for a bit-block
+- unsigned char find_bit_best_encoding(const bm::word_t* block);
++ unsigned char find_bit_best_encoding(const bm::word_t* block) BMNOEXCEPT;
+
+ /// Determine best representation for a bit-block (level 5)
+- unsigned char find_bit_best_encoding_l5(const bm::word_t* block);
++ unsigned char find_bit_best_encoding_l5(const bm::word_t* block) BMNOEXCEPT;
+
+ /// Reset all accumulated compression statistics
+- void reset_compression_stats();
++ void reset_compression_stats() BMNOEXCEPT;
+
+- void reset_models() { mod_size_ = 0; }
+- void add_model(unsigned char mod, unsigned score);
++ void reset_models() BMNOEXCEPT { mod_size_ = 0; }
++ void add_model(unsigned char mod, unsigned score) BMNOEXCEPT;
+ protected:
+
+ /// Bookmark state structure
+ struct bookmark_state
+ {
+- bookmark_state(block_idx_type nb_range)
++ bookmark_state(block_idx_type nb_range) BMNOEXCEPT
+ : ptr_(0), nb_(0),
+ nb_range_(nb_range), bm_type_(0)
+ {
+@@ -364,7 +369,7 @@
+ */
+ static
+ void process_bookmark(block_idx_type nb, bookmark_state& bookm,
+- bm::encoder& enc);
++ bm::encoder& enc) BMNOEXCEPT;
+
+ private:
+ serializer(const serializer&);
+@@ -421,6 +426,8 @@
+ protected:
+ typedef DEC decoder_type;
+ typedef BLOCK_IDX block_idx_type;
++ typedef bm::bit_in<DEC> bit_in_type;
++
+ protected:
+ deseriaizer_base()
+ : id_array_(0), bookmark_idx_(0), skip_offset_(0), skip_pos_(0)
+@@ -440,29 +447,31 @@
+ bm::gap_word_t* dst_arr);
+
+ /// Read binary interpolated list into a bit-set
+- void read_bic_arr(decoder_type& decoder, bm::word_t* blk);
++ void read_bic_arr(decoder_type& decoder, bm::word_t* blk) BMNOEXCEPT;
+
+ /// Read binary interpolated gap blocks into a bitset
+- void read_bic_gap(decoder_type& decoder, bm::word_t* blk);
++ void read_bic_gap(decoder_type& decoder, bm::word_t* blk) BMNOEXCEPT;
+
+ /// Read inverted binary interpolated list into a bit-set
+- void read_bic_arr_inv(decoder_type& decoder, bm::word_t* blk);
++ void read_bic_arr_inv(decoder_type& decoder, bm::word_t* blk) BMNOEXCEPT;
+
+ /// Read digest0-type bit-block
+- void read_digest0_block(decoder_type& decoder, bm::word_t* blk);
++ void read_digest0_block(decoder_type& decoder, bm::word_t* blk) BMNOEXCEPT;
+
+
+ /// read bit-block encoded as runs
+ static
+- void read_0runs_block(decoder_type& decoder, bm::word_t* blk);
++ void read_0runs_block(decoder_type& decoder, bm::word_t* blk) BMNOEXCEPT;
+
+ static
+- const char* err_msg() { return "BM::Invalid serialization format"; }
++ const char* err_msg() BMNOEXCEPT { return "BM::Invalid serialization format"; }
+
+ /// Try to skip if skip bookmark is available within reach
+ /// @return new block idx if skip went well
+ ///
+- block_idx_type try_skip(decoder_type& decoder, block_idx_type nb, block_idx_type expect_nb);
++ block_idx_type try_skip(decoder_type& decoder,
++ block_idx_type nb,
++ block_idx_type expect_nb) BMNOEXCEPT;
+
+ protected:
+ bm::gap_word_t* id_array_; ///< ptr to idx array for temp decode use
+@@ -519,7 +528,7 @@
+ is not guaranteed to be absent
+ @sa unset_range()
+ */
+- void set_range(size_type from, size_type to)
++ void set_range(size_type from, size_type to) BMNOEXCEPT
+ {
+ is_range_set_ = 1; idx_from_ = from; idx_to_ = to;
+ }
+@@ -528,7 +537,7 @@
+ Disable range deserialization
+ @sa set_range()
+ */
+- void unset_range() { is_range_set_ = 0; }
++ void unset_range() BMNOEXCEPT { is_range_set_ = 0; }
+
+ protected:
+ typedef typename BV::blocks_manager_type blocks_manager_type;
+@@ -608,7 +617,7 @@
+ void set_range(size_type from, size_type to);
+
+ /// disable range filtration
+- void unset_range() { is_range_set_ = false; }
++ void unset_range() BMNOEXCEPT { is_range_set_ = false; }
+
+ size_type deserialize(bvector_type& bv,
+ serial_iterator_type& sit,
+@@ -639,7 +648,8 @@
+ serial_iterator_type& sit,
+ set_operation op);
+ static
+- const char* err_msg() { return "BM::de-serialization format error"; }
++ const char* err_msg() BMNOEXCEPT
++ { return "BM::de-serialization format error"; }
+ private:
+ bool is_range_set_ = false;
+ size_type nb_range_from_ = 0;
+@@ -675,7 +685,7 @@
+ void next();
+
+ /// skip all zero or all-one blocks
+- block_idx_type skip_mono_blocks();
++ block_idx_type skip_mono_blocks() BMNOEXCEPT;
+
+ /// read bit block, using logical operation
+ unsigned get_bit_block(bm::word_t* dst_block,
+@@ -708,17 +718,17 @@
+ };
+
+ /// Returns iterator internal state
+- iterator_state state() const { return this->state_; }
++ iterator_state state() const BMNOEXCEPT { return this->state_; }
+
+- iterator_state get_state() const { return this->state_; }
++ iterator_state get_state() const BMNOEXCEPT { return this->state_; }
+ /// Number of ids in the inverted list (valid for e_list_ids)
+- unsigned get_id_count() const { return this->id_cnt_; }
++ unsigned get_id_count() const BMNOEXCEPT { return this->id_cnt_; }
+
+ /// Get last id from the id list
+- bm::id_t get_id() const { return this->last_id_; }
++ bm::id_t get_id() const BMNOEXCEPT { return this->last_id_; }
+
+ /// Get current block index
+- block_idx_type block_idx() const { return this->block_idx_; }
++ block_idx_type block_idx() const BMNOEXCEPT { return this->block_idx_; }
+
+ public:
+ /// member function pointer for bitset-bitset get operations
+@@ -761,19 +771,19 @@
+ /// (Converts inverted list into bits)
+ /// Returns number of words (bits) being read
+ unsigned get_arr_bit(bm::word_t* dst_block,
+- bool clear_target=true);
++ bool clear_target=true) BMNOEXCEPT;
+
+ /// Get current block type
+- unsigned get_block_type() const { return block_type_; }
++ unsigned get_block_type() const BMNOEXCEPT { return block_type_; }
+
+- unsigned get_bit();
++ unsigned get_bit() BMNOEXCEPT;
+
+- void get_inv_arr(bm::word_t* block);
++ void get_inv_arr(bm::word_t* block) BMNOEXCEPT;
+
+ /// Try to skip if skip bookmark is available within reach
+ /// @return true if skip went well
+ ///
+- bool try_skip(block_idx_type nb, block_idx_type expect_nb)
++ bool try_skip(block_idx_type nb, block_idx_type expect_nb) BMNOEXCEPT
+ {
+ block_idx_type new_nb = parent_type::try_skip(decoder_, nb, expect_nb);
+ if (new_nb)
+@@ -1064,6 +1074,7 @@
+ gap_serial_(false),
+ byte_order_serial_(true),
+ sb_bookmarks_(false),
++ sb_range_(0),
+ compression_level_(bm::set_compression_default),
+ ref_vect_(0),
+ ref_idx_(0),
+@@ -1097,7 +1108,7 @@
+
+
+ template<class BV>
+-void serializer<BV>::reset_compression_stats()
++void serializer<BV>::reset_compression_stats() BMNOEXCEPT
+ {
+ for (unsigned i = 0; i < 256; ++i)
+ compression_stat_[i] = 0;
+@@ -1105,7 +1116,7 @@
+
+
+ template<class BV>
+-void serializer<BV>::set_compression_level(unsigned clevel)
++void serializer<BV>::set_compression_level(unsigned clevel) BMNOEXCEPT
+ {
+ if (clevel <= bm::set_compression_max)
+ compression_level_ = clevel;
+@@ -1112,23 +1123,23 @@
+ }
+
+ template<class BV>
+-void serializer<BV>::gap_length_serialization(bool value)
++void serializer<BV>::gap_length_serialization(bool value) BMNOEXCEPT
+ {
+ gap_serial_ = value;
+ }
+
+ template<class BV>
+-void serializer<BV>::byte_order_serialization(bool value)
++void serializer<BV>::byte_order_serialization(bool value) BMNOEXCEPT
+ {
+ byte_order_serial_ = value;
+ }
+
+ template<class BV>
+-void serializer<BV>::set_bookmarks(bool enable, unsigned bm_interval)
++void serializer<BV>::set_bookmarks(bool enable, unsigned bm_interval) BMNOEXCEPT
+ {
+ sb_bookmarks_ = enable;
+ if (enable)
+- {
++ {
+ if (bm_interval > 512)
+ bm_interval = 512;
+ else
+@@ -1148,13 +1159,13 @@
+ }
+
+ template<class BV>
+-void serializer<BV>::set_curr_ref_idx(size_type ref_idx)
++void serializer<BV>::set_curr_ref_idx(size_type ref_idx) BMNOEXCEPT
+ {
+ ref_idx_ = ref_idx;
+ }
+
+ template<class BV>
+-void serializer<BV>::encode_header(const BV& bv, bm::encoder& enc)
++void serializer<BV>::encode_header(const BV& bv, bm::encoder& enc) BMNOEXCEPT
+ {
+ const blocks_manager_type& bman = bv.get_blocks_manager();
+
+@@ -1207,7 +1218,7 @@
+
+ template<class BV>
+ void serializer<BV>::interpolated_encode_gap_block(
+- const bm::gap_word_t* gap_block, bm::encoder& enc)
++ const bm::gap_word_t* gap_block, bm::encoder& enc) BMNOEXCEPT
+ {
+ unsigned len = bm::gap_length(gap_block);
+ if (len > 4) // BIC encoding
+@@ -1266,7 +1277,8 @@
+
+
+ template<class BV>
+-void serializer<BV>::gamma_gap_block(const bm::gap_word_t* gap_block, bm::encoder& enc)
++void serializer<BV>::gamma_gap_block(const bm::gap_word_t* gap_block,
++ bm::encoder& enc) BMNOEXCEPT
+ {
+ unsigned len = gap_length(gap_block);
+ if (len > 3 && (compression_level_ > 3)) // Use Elias Gamma encoding
+@@ -1307,7 +1319,7 @@
+ void serializer<BV>::gamma_gap_array(const bm::gap_word_t* gap_array,
+ unsigned arr_len,
+ bm::encoder& enc,
+- bool inverted)
++ bool inverted) BMNOEXCEPT
+ {
+ unsigned char scode = inverted ? bm::set_block_arrgap_egamma_inv
+ : bm::set_block_arrgap_egamma;
+@@ -1349,10 +1361,11 @@
+
+
+ template<class BV>
+-void serializer<BV>::interpolated_gap_array_v0(const bm::gap_word_t* gap_block,
+- unsigned arr_len,
+- bm::encoder& enc,
+- bool inverted)
++void serializer<BV>::interpolated_gap_array_v0(
++ const bm::gap_word_t* gap_block,
++ unsigned arr_len,
++ bm::encoder& enc,
++ bool inverted) BMNOEXCEPT
+ {
+ BM_ASSERT(arr_len <= 65535);
+ unsigned char scode = inverted ? bm::set_block_arrgap_bienc_inv
+@@ -1399,7 +1412,7 @@
+ void serializer<BV>::interpolated_gap_array(const bm::gap_word_t* gap_block,
+ unsigned arr_len,
+ bm::encoder& enc,
+- bool inverted)
++ bool inverted) BMNOEXCEPT
+ {
+ BM_ASSERT(arr_len <= 65535);
+
+@@ -1471,7 +1484,7 @@
+
+
+ template<class BV>
+-void serializer<BV>::add_model(unsigned char mod, unsigned score)
++void serializer<BV>::add_model(unsigned char mod, unsigned score) BMNOEXCEPT
+ {
+ BM_ASSERT(mod_size_ < 64); // too many models (memory corruption?)
+ scores_[mod_size_] = score; models_[mod_size_] = mod;
+@@ -1479,7 +1492,8 @@
+ }
+
+ template<class BV>
+-unsigned char serializer<BV>::find_bit_best_encoding_l5(const bm::word_t* block)
++unsigned char
++serializer<BV>::find_bit_best_encoding_l5(const bm::word_t* block) BMNOEXCEPT
+ {
+ unsigned bc, bit_gaps;
+
+@@ -1566,7 +1580,8 @@
+ }
+
+ template<class BV>
+-unsigned char serializer<BV>::find_bit_best_encoding(const bm::word_t* block)
++unsigned char
++serializer<BV>::find_bit_best_encoding(const bm::word_t* block) BMNOEXCEPT
+ {
+ reset_models();
+
+@@ -1672,7 +1687,7 @@
+
+ template<class BV>
+ unsigned char
+-serializer<BV>::find_gap_best_encoding(const bm::gap_word_t* gap_block)
++serializer<BV>::find_gap_best_encoding(const bm::gap_word_t* gap_block)BMNOEXCEPT
+ {
+ // heuristics and hard-coded rules to determine
+ // the best representation for d-GAP block
+@@ -1731,9 +1746,9 @@
+ break;
+
+ case bm::set_block_bit_1bit:
+- arr_len = gap_convert_to_arr(gap_temp_block,
+- gap_block,
+- bm::gap_equiv_len-10);
++ arr_len = bm::gap_convert_to_arr(gap_temp_block,
++ gap_block,
++ bm::gap_equiv_len-10);
+ BM_ASSERT(arr_len == 1);
+ enc.put_8(bm::set_block_bit_1bit);
+ enc.put_16(gap_temp_block[0]);
+@@ -1779,7 +1794,7 @@
+ void serializer<BV>::encode_bit_interval(const bm::word_t* blk,
+ bm::encoder& enc,
+ unsigned //size_control
+- )
++ ) BMNOEXCEPT
+ {
+ enc.put_8(bm::set_block_bit_0runs);
+ enc.put_8((blk[0]==0) ? 0 : 1); // encode start
+@@ -1830,7 +1845,7 @@
+ template<class BV>
+ void serializer<BV>::encode_bit_digest(const bm::word_t* block,
+ bm::encoder& enc,
+- bm::id64_t d0)
++ bm::id64_t d0) BMNOEXCEPT
+ {
+ // evaluate a few "sure" models here and pick the best
+ //
+@@ -1927,16 +1942,16 @@
+ template<class BV>
+ void serializer<BV>::encode_bit_array(const bm::word_t* block,
+ bm::encoder& enc,
+- bool inverted)
++ bool inverted) BMNOEXCEPT
+ {
+ unsigned arr_len;
+ unsigned mask = inverted ? ~0u : 0u;
+ // TODO: get rid of max bits
+- arr_len = bit_convert_to_arr(bit_idx_arr_.data(),
+- block,
+- bm::gap_max_bits,
+- bm::gap_max_bits_cmrz,
+- mask);
++ arr_len = bm::bit_convert_to_arr(bit_idx_arr_.data(),
++ block,
++ bm::gap_max_bits,
++ bm::gap_max_bits_cmrz,
++ mask);
+ if (arr_len)
+ {
+ unsigned char scode =
+@@ -1950,7 +1965,7 @@
+
+ template<class BV>
+ void serializer<BV>::gamma_gap_bit_block(const bm::word_t* block,
+- bm::encoder& enc)
++ bm::encoder& enc) BMNOEXCEPT
+ {
+ unsigned len = bm::bit_to_gap(bit_idx_arr_.data(), block, bm::gap_equiv_len);
+ BM_ASSERT(len); (void)len;
+@@ -1959,7 +1974,8 @@
+
+ template<class BV>
+ void serializer<BV>::gamma_arr_bit_block(const bm::word_t* block,
+- bm::encoder& enc, bool inverted)
++ bm::encoder& enc,
++ bool inverted) BMNOEXCEPT
+ {
+ unsigned mask = inverted ? ~0u : 0u;
+ unsigned arr_len = bit_convert_to_arr(bit_idx_arr_.data(),
+@@ -1978,7 +1994,8 @@
+
+ template<class BV>
+ void serializer<BV>::bienc_arr_bit_block(const bm::word_t* block,
+- bm::encoder& enc, bool inverted)
++ bm::encoder& enc,
++ bool inverted) BMNOEXCEPT
+ {
+ unsigned mask = inverted ? ~0u : 0u;
+ unsigned arr_len = bit_convert_to_arr(bit_idx_arr_.data(),
+@@ -1996,7 +2013,7 @@
+
+ template<class BV>
+ void serializer<BV>::interpolated_gap_bit_block(const bm::word_t* block,
+- bm::encoder& enc)
++ bm::encoder& enc) BMNOEXCEPT
+ {
+ unsigned len = bm::bit_to_gap(bit_idx_arr_.data(), block, bm::gap_max_bits);
+ BM_ASSERT(len); (void)len;
+@@ -2006,7 +2023,7 @@
+
+ template<class BV>
+ void serializer<BV>::bienc_gap_bit_block(const bm::word_t* block,
+- bm::encoder& enc)
++ bm::encoder& enc) BMNOEXCEPT
+ {
+ unsigned len = bm::bit_to_gap(bit_idx_arr_.data(), block, bm::gap_max_bits);
+ BM_ASSERT(len); (void)len;
+@@ -2052,8 +2069,10 @@
+
+
+ template<class BV>
+-void serializer<BV>::interpolated_arr_bit_block(const bm::word_t* block,
+- bm::encoder& enc, bool inverted)
++void
++serializer<BV>::interpolated_arr_bit_block(const bm::word_t* block,
++ bm::encoder& enc,
++ bool inverted) BMNOEXCEPT
+ {
+ unsigned mask = inverted ? ~0u : 0u;
+ unsigned arr_len = bit_convert_to_arr(bit_idx_arr_.data(),
+@@ -2134,7 +2153,7 @@
+ template<class BV>
+ void serializer<BV>::process_bookmark(block_idx_type nb,
+ bookmark_state& bookm,
+- bm::encoder& enc)
++ bm::encoder& enc) BMNOEXCEPT
+ {
+ BM_ASSERT(bookm.nb_range_);
+
+@@ -2786,8 +2805,6 @@
+ unsigned block_type,
+ bm::gap_word_t* dst_arr)
+ {
+- typedef bit_in<DEC> bit_in_type;
+-
+ bm::gap_word_t len = 0;
+
+ switch (block_type)
+@@ -2867,12 +2884,12 @@
+ }
+
+ template<typename DEC, typename BLOCK_IDX>
+-void deseriaizer_base<DEC, BLOCK_IDX>::read_bic_arr(decoder_type& dec,
+- bm::word_t* blk)
++void
++deseriaizer_base<DEC, BLOCK_IDX>::read_bic_arr(decoder_type& dec,
++ bm::word_t* blk) BMNOEXCEPT
+ {
+ BM_ASSERT(!BM_IS_GAP(blk));
+
+- typedef bit_in<DEC> bit_in_type;
+ bm::gap_word_t min_v = dec.get_16();
+ bm::gap_word_t max_v = dec.get_16();
+ unsigned arr_len = dec.get_16();
+@@ -2890,7 +2907,9 @@
+ }
+
+ template<typename DEC, typename BLOCK_IDX>
+-void deseriaizer_base<DEC, BLOCK_IDX>::read_bic_arr_inv(decoder_type& decoder, bm::word_t* blk)
++void
++deseriaizer_base<DEC, BLOCK_IDX>::read_bic_arr_inv(decoder_type& decoder,
++ bm::word_t* blk) BMNOEXCEPT
+ {
+ // TODO: optimization
+ bm::bit_block_set(blk, 0);
+@@ -2899,18 +2918,16 @@
+ }
+
+ template<typename DEC, typename BLOCK_IDX>
+-void deseriaizer_base<DEC, BLOCK_IDX>::read_bic_gap(decoder_type& dec, bm::word_t* blk)
++void deseriaizer_base<DEC, BLOCK_IDX>::read_bic_gap(decoder_type& dec,
++ bm::word_t* blk) BMNOEXCEPT
+ {
+ BM_ASSERT(!BM_IS_GAP(blk));
+
+- typedef bit_in<DEC> bit_in_type;
+-
+ bm::gap_word_t head = dec.get_8();
+ unsigned arr_len = dec.get_16();
+ bm::gap_word_t min_v = dec.get_16();
+
+ BM_ASSERT(arr_len <= bie_cut_off);
+-
+
+ id_array_[0] = head;
+ id_array_[1] = min_v;
+@@ -2920,15 +2937,14 @@
+ bin.bic_decode_u16(&id_array_[2], arr_len-2, min_v, 65535);
+
+ if (!IS_VALID_ADDR(blk))
+- {
+ return;
+- }
+ bm::gap_add_to_bitset(blk, id_array_, arr_len);
+ }
+
+ template<typename DEC, typename BLOCK_IDX>
+-void deseriaizer_base<DEC, BLOCK_IDX>::read_digest0_block(decoder_type& dec,
+- bm::word_t* block)
++void deseriaizer_base<DEC, BLOCK_IDX>::read_digest0_block(
++ decoder_type& dec,
++ bm::word_t* block) BMNOEXCEPT
+ {
+ bm::id64_t d0 = dec.get_64();
+ while (d0)
+@@ -2966,8 +2982,9 @@
+ }
+
+ template<typename DEC, typename BLOCK_IDX>
+-void deseriaizer_base<DEC, BLOCK_IDX>::read_0runs_block(decoder_type& dec,
+- bm::word_t* blk)
++void deseriaizer_base<DEC, BLOCK_IDX>::read_0runs_block(
++ decoder_type& dec,
++ bm::word_t* blk) BMNOEXCEPT
+ {
+ //TODO: optimization if block exists and it is OR-ed read
+ bm::bit_block_set(blk, 0);
+@@ -2995,13 +3012,13 @@
+
+
+ template<typename DEC, typename BLOCK_IDX>
+-void deseriaizer_base<DEC, BLOCK_IDX>::read_gap_block(decoder_type& decoder,
++void
++deseriaizer_base<DEC, BLOCK_IDX>::read_gap_block(decoder_type& decoder,
+ unsigned block_type,
+ bm::gap_word_t* dst_block,
+ bm::gap_word_t& gap_head)
+ {
+- typedef bit_in<DEC> bit_in_type;
+-
++// typedef bit_in<DEC> bit_in_type;
+ switch (block_type)
+ {
+ case set_block_gap:
+@@ -3028,7 +3045,7 @@
+ for (gap_word_t k = 0; k < len; ++k)
+ {
+ gap_word_t bit_idx = decoder.get_16();
+- gap_add_value(dst_block, bit_idx);
++ bm::gap_add_value(dst_block, bit_idx);
+ } // for
+ }
+ break;
+@@ -3126,7 +3143,7 @@
+ deseriaizer_base<DEC, BLOCK_IDX>::try_skip(
+ decoder_type& decoder,
+ block_idx_type nb,
+- block_idx_type expect_nb)
++ block_idx_type expect_nb) BMNOEXCEPT
+ {
+ if (skip_offset_) // skip bookmark is available
+ {
+@@ -3156,26 +3173,22 @@
+ nb_sync = decoder.get_32();
+ break;
+ case set_nb_sync_mark48:
++ nb_sync = block_idx_type(decoder.get_48());
+ #ifndef BM64ADDR
+ BM_ASSERT(0);
+- #ifndef BM_NO_STL
+- throw std::logic_error(this->err_msg());
+- #else
+- BM_THROW(BM_ERR_SERIALFORMAT);
+- #endif
++ decoder.set_pos(save_pos);
++ skip_offset_ = 0;
++ return 0; // invalid bookmark from 64-bit serialization
+ #endif
+- nb_sync = block_idx_type(decoder.get_48());
+ break;
+ case set_nb_sync_mark64:
++ nb_sync = block_idx_type(decoder.get_64());
+ #ifndef BM64ADDR
+ BM_ASSERT(0);
+- #ifndef BM_NO_STL
+- throw std::logic_error(this->err_msg());
+- #else
+- BM_THROW(BM_ERR_SERIALFORMAT);
+- #endif
++ decoder.set_pos(save_pos);
++ skip_offset_ = 0;
++ return 0; // invalid bookmark from 64-bit serialization
+ #endif
+- nb_sync = block_idx_type(decoder.get_64());
+ break;
+ default:
+ BM_ASSERT(0);
+@@ -3187,8 +3200,6 @@
+ nb_sync += nb;
+ if (nb_sync <= expect_nb) // within reach
+ {
+- //block_idx_ = nb_sync;
+- //state_ = e_blocks;
+ skip_offset_ = 0;
+ return nb_sync;
+ }
+@@ -3593,6 +3604,7 @@
+ {
+ // 64-bit vector cannot be deserialized into 32-bit
+ BM_ASSERT(sizeof(block_idx_type)==8);
++ bv_size = (block_idx_type)dec.get_64();
+ #ifndef BM64ADDR
+ #ifndef BM_NO_STL
+ throw std::logic_error(this->err_msg());
+@@ -3600,7 +3612,6 @@
+ BM_THROW(BM_ERR_SERIALFORMAT);
+ #endif
+ #endif
+- bv_size = (block_idx_type)dec.get_64();
+ }
+ else
+ bv_size = dec.get_32();
+@@ -3715,12 +3726,12 @@
+ goto process_full_blocks;
+ #else
+ BM_ASSERT(0); // 32-bit vector cannot read 64-bit
++ dec.get_64();
+ #ifndef BM_NO_STL
+ throw std::logic_error(this->err_msg());
+ #else
+ BM_THROW(BM_ERR_SERIALFORMAT);
+ #endif
+- dec.get_64();
+ #endif
+ process_full_blocks:
+ {
+@@ -3957,7 +3968,7 @@
+ template<class BV, class DEC>
+ void deserializer<BV, DEC>::xor_decode(size_type x_ref_idx, bm::id64_t x_ref_d64,
+ blocks_manager_type& bman,
+- block_idx_type nb)
++ block_idx_type nb)
+ {
+ BM_ASSERT(ref_vect_);
+
+@@ -4098,7 +4109,15 @@
+ }
+ state_ = e_blocks;
+ }
+- block_idx_arr_ = (gap_word_t*) ::malloc(sizeof(gap_word_t) * bm::gap_max_bits);
++ block_idx_arr_=(gap_word_t*)::malloc(sizeof(gap_word_t) * bm::gap_max_bits);
++ if (!block_idx_arr_)
++ {
++ #ifndef BM_NO_STL
++ throw std::bad_alloc();
++ #else
++ BM_THROW(BM_ERR_BADALLOC);
++ #endif
++ }
+ this->id_array_ = block_idx_arr_;
+ }
+
+@@ -4335,7 +4354,7 @@
+
+ template<typename DEC, typename BLOCK_IDX>
+ typename serial_stream_iterator<DEC, BLOCK_IDX>::block_idx_type
+-serial_stream_iterator<DEC, BLOCK_IDX>::skip_mono_blocks()
++serial_stream_iterator<DEC, BLOCK_IDX>::skip_mono_blocks() BMNOEXCEPT
+ {
+ BM_ASSERT(state_ == e_zero_blocks || state_ == e_one_blocks);
+ if (!mono_block_cnt_)
+@@ -4350,7 +4369,8 @@
+ }
+
+ template<typename DEC, typename BLOCK_IDX>
+-void serial_stream_iterator<DEC, BLOCK_IDX>::get_inv_arr(bm::word_t* block)
++void
++serial_stream_iterator<DEC, BLOCK_IDX>::get_inv_arr(bm::word_t* block) BMNOEXCEPT
+ {
+ gap_word_t len = decoder_.get_16();
+ if (block)
+@@ -4358,7 +4378,7 @@
+ bm::bit_block_set(block, ~0u);
+ for (unsigned k = 0; k < len; ++k)
+ {
+- gap_word_t bit_idx = decoder_.get_16();
++ bm::gap_word_t bit_idx = decoder_.get_16();
+ bm::clear_bit(block, bit_idx);
+ }
+ }
+@@ -5519,8 +5539,8 @@
+
+ template<typename DEC, typename BLOCK_IDX>
+ unsigned serial_stream_iterator<DEC, BLOCK_IDX>::get_arr_bit(
+- bm::word_t* dst_block,
+- bool clear_target)
++ bm::word_t* dst_block,
++ bool clear_target) BMNOEXCEPT
+ {
+ BM_ASSERT(this->block_type_ == set_block_arrbit ||
+ this->block_type_ == set_block_bit_1bit);
+@@ -5547,10 +5567,9 @@
+ else
+ {
+ if (this->block_type_ == set_block_bit_1bit)
+- {
+- return 1; // nothing to do: len var already consumed 16bits
+- }
+- // fwd the decocing stream
++ return 1; // nothing to do: len var already consumed 16 bits
++
++ // fwd the decode stream
+ decoder_.seek(len * 2);
+ }
+ return len;
+@@ -5557,7 +5576,7 @@
+ }
+
+ template<typename DEC, typename BLOCK_IDX>
+-unsigned serial_stream_iterator<DEC, BLOCK_IDX>::get_bit()
++unsigned serial_stream_iterator<DEC, BLOCK_IDX>::get_bit() BMNOEXCEPT
+ {
+ BM_ASSERT(this->block_type_ == set_block_bit_1bit);
+ ++(this->block_idx_);
+Index: c++/include/util/bitset/bm.h
+===================================================================
+--- a/c++/include/util/bitset/bm.h (revision 90103)
++++ b/c++/include/util/bitset/bm.h (revision 90104)
+@@ -145,12 +145,12 @@
+ class reference
+ {
+ public:
+- reference(bvector<Alloc>& bv, size_type position)
++ reference(bvector<Alloc>& bv, size_type position) BMNOEXCEPT
+ : bv_(bv),
+ position_(position)
+ {}
+
+- reference(const reference& ref)
++ reference(const reference& ref) BMNOEXCEPT
+ : bv_(ref.bv_),
+ position_(ref.position_)
+ {
+@@ -157,7 +157,7 @@
+ bv_.set(position_, ref.bv_.get_bit(position_));
+ }
+
+- operator bool() const
++ operator bool() const BMNOEXCEPT
+ {
+ return bv_.get_bit(position_);
+ }
+@@ -168,13 +168,13 @@
+ return *this;
+ }
+
+- const reference& operator=(bool value) const
++ const reference& operator=(bool value) const BMNOEXCEPT
+ {
+ bv_.set(position_, value);
+ return *this;
+ }
+
+- bool operator==(const reference& ref) const
++ bool operator==(const reference& ref) const BMNOEXCEPT
+ {
+ return bool(*this) == bool(ref);
+ }
+@@ -204,13 +204,13 @@
+ }
+
+ /*! Logical Not operator */
+- bool operator!() const
++ bool operator!() const BMNOEXCEPT
+ {
+ return !bv_.get_bit(position_);
+ }
+
+ /*! Bit Not operator */
+- bool operator~() const
++ bool operator~() const BMNOEXCEPT
+ {
+ return !bv_.get_bit(position_);
+ }
+@@ -237,34 +237,37 @@
+ {
+ friend class bvector;
+ public:
+- iterator_base() : bv_(0), position_(bm::id_max), block_(0) {}
++ iterator_base() BMNOEXCEPT
++ : bv_(0), position_(bm::id_max), block_(0), block_type_(0),
++ block_idx_(0)
++ {}
+
+- bool operator==(const iterator_base& it) const
++ bool operator==(const iterator_base& it) const BMNOEXCEPT
+ {
+ return (position_ == it.position_) && (bv_ == it.bv_);
+ }
+
+- bool operator!=(const iterator_base& it) const
++ bool operator!=(const iterator_base& it) const BMNOEXCEPT
+ {
+ return ! operator==(it);
+ }
+
+- bool operator < (const iterator_base& it) const
++ bool operator < (const iterator_base& it) const BMNOEXCEPT
+ {
+ return position_ < it.position_;
+ }
+
+- bool operator <= (const iterator_base& it) const
++ bool operator <= (const iterator_base& it) const BMNOEXCEPT
+ {
+ return position_ <= it.position_;
+ }
+
+- bool operator > (const iterator_base& it) const
++ bool operator > (const iterator_base& it) const BMNOEXCEPT
+ {
+ return position_ > it.position_;
+ }
+
+- bool operator >= (const iterator_base& it) const
++ bool operator >= (const iterator_base& it) const BMNOEXCEPT
+ {
+ return position_ >= it.position_;
+ }
+@@ -274,18 +277,19 @@
+ \brief Checks if iterator is still valid. Analog of != 0 comparison for pointers.
+ \returns true if iterator is valid.
+ */
+- bool valid() const { return position_ != bm::id_max; }
++ bool valid() const BMNOEXCEPT { return position_ != bm::id_max; }
+
+ /**
+ \fn bool bm::bvector::iterator_base::invalidate()
+ \brief Turns iterator into an invalid state.
+ */
+- void invalidate() { position_ = bm::id_max; }
++ void invalidate() BMNOEXCEPT
++ { position_ = bm::id_max; block_type_ = ~0u;}
+
+ /** \brief Compare FSMs for testing purposes
+ \internal
+ */
+- bool compare_state(const iterator_base& ib) const
++ bool compare_state(const iterator_base& ib) const BMNOEXCEPT
+ {
+ if (this->bv_ != ib.bv_) return false;
+ if (this->position_ != ib.position_) return false;
+@@ -317,7 +321,9 @@
+
+ public:
+
+- /** Information about current bitblock. */
++ /** Bit-block descriptor
++ @internal
++ */
+ struct bitblock_descr
+ {
+ const bm::word_t* ptr; //!< Word pointer.
+@@ -327,7 +333,9 @@
+ size_type pos; //!< Last bit position decode before
+ };
+
+- /** Information about current DGAP block. */
++ /** Information about current DGAP block.
++ @internal
++ */
+ struct dgap_descr
+ {
+ const gap_word_t* ptr; //!< Word pointer.
+@@ -379,9 +387,9 @@
+ typedef void pointer;
+ typedef void reference;
+
+- insert_iterator() : bvect_(0), max_bit_(0) {}
++ insert_iterator() BMNOEXCEPT : bvect_(0), max_bit_(0) {}
+
+- insert_iterator(bvector<Alloc>& bvect)
++ insert_iterator(bvector<Alloc>& bvect) BMNOEXCEPT
+ : bvect_(&bvect),
+ max_bit_(bvect.size())
+ {
+@@ -463,7 +471,7 @@
+ typedef void pointer;
+ typedef void reference;
+
+- bulk_insert_iterator()
++ bulk_insert_iterator() BMNOEXCEPT
+ : bvect_(0), buf_(0), buf_size_(0), sorted_(BM_UNKNOWN) {}
+
+ ~bulk_insert_iterator()
+@@ -473,7 +481,8 @@
+ bvect_->blockman_.get_allocator().free_bit_block((bm::word_t*)buf_);
+ }
+
+- bulk_insert_iterator(bvector<Alloc>& bvect, bm::sort_order so = BM_UNKNOWN)
++ bulk_insert_iterator(bvector<Alloc>& bvect,
++ bm::sort_order so = BM_UNKNOWN) BMNOEXCEPT
+ : bvect_(&bvect), sorted_(so)
+ {
+ bvect_->init();
+@@ -499,7 +508,7 @@
+ sorted_ = BM_UNKNOWN;
+ }
+
+- bulk_insert_iterator(bulk_insert_iterator&& iit) BMNOEXEPT
++ bulk_insert_iterator(bulk_insert_iterator&& iit) BMNOEXCEPT
+ : bvect_(iit.bvect_)
+ {
+ buf_ = iit.buf_; iit.buf_ = 0;
+@@ -518,7 +527,7 @@
+ return *this;
+ }
+
+- bulk_insert_iterator& operator=(bulk_insert_iterator&& ii) BMNOEXEPT
++ bulk_insert_iterator& operator=(bulk_insert_iterator&& ii) BMNOEXCEPT
+ {
+ bvect_ = ii.bvect_;
+ if (buf_)
+@@ -562,11 +571,11 @@
+ bvect_->sync_size();
+ }
+
+- bvector_type* get_bvector() const { return bvect_; }
++ bvector_type* get_bvector() const BMNOEXCEPT { return bvect_; }
+
+ protected:
+ static
+- size_type buf_size_max()
++ size_type buf_size_max() BMNOEXCEPT
+ {
+ #ifdef BM64ADDR
+ return bm::set_block_size / 2;
+@@ -599,7 +608,7 @@
+ typedef unsigned& reference;
+
+ public:
+- enumerator() : iterator_base()
++ enumerator() BMNOEXCEPT : iterator_base()
+ {}
+
+ /*! @brief Construct enumerator associated with a vector.
+@@ -606,7 +615,7 @@
+ This construction creates unpositioned iterator with status
+ valid() == false. It can be re-positioned using go_first() or go_to()
+ */
+- enumerator(const bvector<Alloc>* bv)
++ enumerator(const bvector<Alloc>* bv) BMNOEXCEPT
+ : iterator_base()
+ {
+ this->bv_ = const_cast<bvector<Alloc>*>(bv);
+@@ -613,12 +622,26 @@
+ }
+
+ /*! @brief Construct enumerator for bit vector
++ @param bv bit-vector reference
++ @param pos bit position in the vector
++ if position is 0, it finds the next 1 or becomes not valid
++ (en.valid() == false)
++ */
++ enumerator(const bvector<Alloc>& bv, size_type pos = 0) BMNOEXCEPT
++ : iterator_base()
++ {
++ this->bv_ = const_cast<bvector<Alloc>*>(&bv);
++ go_to(pos);
++ }
++
++
++ /*! @brief Construct enumerator for bit vector
+ @param bv bit-vector pointer
+ @param pos bit position in the vector
+ if position is 0, it finds the next 1 or becomes not valid
+ (en.valid() == false)
+ */
+- enumerator(const bvector<Alloc>* bv, size_type pos)
++ enumerator(const bvector<Alloc>* bv, size_type pos) BMNOEXCEPT
+ : iterator_base()
+ {
+ this->bv_ = const_cast<bvector<Alloc>*>(bv);
+@@ -626,18 +649,18 @@
+ }
+
+ /*! \brief Get current position (value) */
+- size_type operator*() const { return this->position_; }
++ size_type operator*() const BMNOEXCEPT { return this->position_; }
+
+ /*! \brief Get current position (value) */
+- size_type value() const { return this->position_; }
++ size_type value() const BMNOEXCEPT { return this->position_; }
+
+ /*! \brief Advance enumerator forward to the next available bit */
+- enumerator& operator++() { return this->go_up(); }
++ enumerator& operator++() BMNOEXCEPT { this->go_up(); return *this; }
+
+ /*! \brief Advance enumerator forward to the next available bit.
+ Possibly do NOT use this operator it is slower than the pre-fix increment.
+ */
+- enumerator operator++(int)
++ enumerator operator++(int) BMNOEXCEPT
+ {
+ enumerator tmp = *this;
+ this->go_up();
+@@ -644,158 +667,28 @@
+ return tmp;
+ }
+
+-
+ /*! \brief Position enumerator to the first available bit */
+- void go_first()
+- {
+- BM_ASSERT(this->bv_);
+-
+- blocks_manager_type* bman = &(this->bv_->blockman_);
+- if (!bman->is_init())
+- {
+- this->invalidate();
+- return;
+- }
+-
+- bm::word_t*** blk_root = bman->top_blocks_root();
++ void go_first() BMNOEXCEPT;
+
+- this->block_idx_ = this->position_= 0;
+- unsigned i, j;
++ /*! advance iterator forward by one
++ @return true if advance was successfull and the enumerator is valid
++ */
++ bool advance() BMNOEXCEPT { return this->go_up(); }
+
+- for (i = 0; i < bman->top_block_size(); ++i)
+- {
+- bm::word_t** blk_blk = blk_root[i];
+-
+- if (blk_blk == 0) // not allocated
+- {
+- this->block_idx_ += bm::set_sub_array_size;
+- this->position_ += bm::bits_in_array;
+- continue;
+- }
+-
+- if ((bm::word_t*)blk_blk == FULL_BLOCK_FAKE_ADDR)
+- blk_blk = FULL_SUB_BLOCK_REAL_ADDR;
+-
+- for (j = 0; j < bm::set_sub_array_size; ++j,++(this->block_idx_))
+- {
+- this->block_ = blk_blk[j];
+-
+- if (this->block_ == 0)
+- {
+- this->position_ += bits_in_block;
+- continue;
+- }
+-
+- if (BM_IS_GAP(this->block_))
+- {
+- this->block_type_ = 1;
+- if (search_in_gapblock())
+- {
+- return;
+- }
+- }
+- else
+- {
+- if (this->block_ == FULL_BLOCK_FAKE_ADDR)
+- this->block_ = FULL_BLOCK_REAL_ADDR;
+-
+- this->block_type_ = 0;
+- if (search_in_bitblock())
+- {
+- return;
+- }
+- }
+-
+- } // for j
+-
+- } // for i
+-
+- this->invalidate();
+- }
+-
+- /// advance iterator forward by one
+- void advance() { this->go_up(); }
+-
+-
+ /*! \brief Advance enumerator to the next available bit */
+- enumerator& go_up()
+- {
+- BM_ASSERT(this->valid());
+- BM_ASSERT_THROW(this->valid(), BM_ERR_RANGE);
++ bool go_up() BMNOEXCEPT;
+
+- // Current block search.
+- //
+-
+- block_descr_type* bdescr = &(this->bdescr_);
+- switch (this->block_type_)
+- {
+- case 0: // BitBlock
+- {
+- // check if we can get the value from the bits traversal cache
+- unsigned short idx = ++(bdescr->bit_.idx);
+- if (idx < bdescr->bit_.cnt)
+- {
+- this->position_ = bdescr->bit_.pos + bdescr->bit_.bits[idx];
+- return *this;
+- }
+- this->position_ +=
+- (bm::set_bitscan_wave_size * 32) - bdescr->bit_.bits[--idx];
+-
+- bdescr->bit_.ptr += bm::set_bitscan_wave_size;
+- if (decode_bit_group(bdescr))
+- {
+- return *this;
+- }
+- }
+- break;
+- case 1: // DGAP Block
+- {
+- ++this->position_;
+- if (--(bdescr->gap_.gap_len))
+- {
+- return *this;
+- }
+-
+- // next gap is "OFF" by definition.
+- if (*(bdescr->gap_.ptr) == bm::gap_max_bits - 1)
+- {
+- break;
+- }
+- gap_word_t prev = *(bdescr->gap_.ptr);
+- unsigned int val = *(++(bdescr->gap_.ptr));
+-
+- this->position_ += val - prev;
+- // next gap is now "ON"
+- if (*(bdescr->gap_.ptr) == bm::gap_max_bits - 1)
+- {
+- break;
+- }
+- prev = *(bdescr->gap_.ptr);
+- val = *(++(bdescr->gap_.ptr));
+- bdescr->gap_.gap_len = (gap_word_t)(val - prev);
+- return *this; // next "ON" found;
+- }
+- default:
+- BM_ASSERT(0);
+-
+- } // switch
+-
+- if (search_in_blocks())
+- return *this;
+-
+- this->invalidate();
+- return *this;
+- }
+-
+ /*!
+ @brief Skip to specified relative rank
+- @param rank - number of ON bits to go for
++ @param rank - number of ON bits to go for (must be: > 0)
++ @return true if skip was successfull and enumerator is valid
+ */
+- enumerator& skip_to_rank(size_type rank)
++ bool skip_to_rank(size_type rank) BMNOEXCEPT
+ {
++ BM_ASSERT(rank);
+ --rank;
+ if (!rank)
+- return *this;
++ return this->valid();
+ return skip(rank);
+ }
+
+@@ -802,329 +695,26 @@
+ /*!
+ @brief Skip specified number of bits from enumeration
+ @param rank - number of ON bits to skip
++ @return true if skip was successfull and enumerator is valid
+ */
+- enumerator& skip(size_type rank)
+- {
+- if (!this->valid() || !rank)
+- return *this;
+- for (; rank; --rank)
+- {
+- block_descr_type* bdescr = &(this->bdescr_);
+- switch (this->block_type_)
+- {
+- case 0: // BitBlock
+- for (; rank; --rank)
+- {
+- unsigned short idx = ++(bdescr->bit_.idx);
+- if (idx < bdescr->bit_.cnt)
+- {
+- this->position_ = bdescr->bit_.pos + bdescr->bit_.bits[idx];
+- continue;
+- }
+- this->position_ +=
+- (bm::set_bitscan_wave_size * 32) - bdescr->bit_.bits[--idx];
+- bdescr->bit_.ptr += bm::set_bitscan_wave_size;
+-
+- if (!decode_bit_group(bdescr, rank))
+- break;
+- } // for rank
+- break;
+- case 1: // DGAP Block
+- for (; rank; --rank) // TODO: better skip logic
+- {
+- ++this->position_;
+- if (--(bdescr->gap_.gap_len))
+- {
+- continue;
+- }
++ bool skip(size_type rank) BMNOEXCEPT;
+
+- // next gap is "OFF" by definition.
+- if (*(bdescr->gap_.ptr) == bm::gap_max_bits - 1)
+- {
+- break;
+- }
+- gap_word_t prev = *(bdescr->gap_.ptr);
+- unsigned int val = *(++(bdescr->gap_.ptr));
+-
+- this->position_ += val - prev;
+- // next gap is now "ON"
+- if (*(bdescr->gap_.ptr) == bm::gap_max_bits - 1)
+- {
+- break;
+- }
+- prev = *(bdescr->gap_.ptr);
+- val = *(++(bdescr->gap_.ptr));
+- bdescr->gap_.gap_len = (gap_word_t)(val - prev);
+- } // for rank
+- break;
+- default:
+- BM_ASSERT(0);
+- } // switch
+-
+- if (!rank)
+- return *this;
+-
+- if (!search_in_blocks())
+- {
+- this->invalidate();
+- return *this;
+- }
+- } // for rank
+- return *this;
+- }
+-
+ /*!
+ @brief go to a specific position in the bit-vector (or next)
+ */
+- enumerator& go_to(size_type pos)
+- {
+- if (pos == 0)
+- {
+- go_first();
+- return *this;
+- }
++ bool go_to(size_type pos) BMNOEXCEPT;
+
+- size_type new_pos = this->bv_->check_or_next(pos); // find the true pos
+- if (new_pos == 0) // no bits available
+- {
+- this->invalidate();
+- return *this;
+- }
+- BM_ASSERT(new_pos >= pos);
+- pos = new_pos;
+-
+-
+- this->position_ = pos;
+- size_type nb = this->block_idx_ = (pos >> bm::set_block_shift);
+- bm::bvector<Alloc>::blocks_manager_type& bman =
+- this->bv_->get_blocks_manager();
+- unsigned i0, j0;
+- bm::get_block_coord(nb, i0, j0);
+- this->block_ = bman.get_block(i0, j0);
+-
+- BM_ASSERT(this->block_);
+-
+- this->block_type_ = (bool)BM_IS_GAP(this->block_);
+-
+- block_descr_type* bdescr = &(this->bdescr_);
+- unsigned nbit = unsigned(pos & bm::set_block_mask);
+-
+- if (this->block_type_) // gap
+- {
+- this->position_ = nb * bm::set_block_size * 32;
+- search_in_gapblock();
+-
+- if (this->position_ == pos)
+- return *this;
+- this->position_ = pos;
+-
+- gap_word_t* gptr = BMGAP_PTR(this->block_);
+- unsigned is_set;
+- unsigned gpos = bm::gap_bfind(gptr, nbit, &is_set);
+- BM_ASSERT(is_set);
+-
+- bdescr->gap_.ptr = gptr + gpos;
+- if (gpos == 1)
+- {
+- bdescr->gap_.gap_len = bm::gap_word_t(gptr[gpos] - (nbit - 1));
+- }
+- else
+- {
+- bm::gap_word_t interval = bm::gap_word_t(gptr[gpos] - gptr[gpos - 1]);
+- bm::gap_word_t interval2 = bm::gap_word_t(nbit - gptr[gpos - 1]);
+- bdescr->gap_.gap_len = bm::gap_word_t(interval - interval2 + 1);
+- }
+- }
+- else // bit
+- {
+- if (nbit == 0)
+- {
+- search_in_bitblock();
+- return *this;
+- }
+-
+- unsigned nword = unsigned(nbit >> bm::set_word_shift);
+-
+- // check if we need to step back to match the wave
+- unsigned parity = nword % bm::set_bitscan_wave_size;
+- bdescr->bit_.ptr = this->block_ + (nword - parity);
+- bdescr->bit_.cnt = bm::bitscan_wave(bdescr->bit_.ptr, bdescr->bit_.bits);
+- BM_ASSERT(bdescr->bit_.cnt);
+- bdescr->bit_.pos = (nb * bm::set_block_size * 32) + ((nword - parity) * 32);
+- bdescr->bit_.idx = 0;
+- nbit &= bm::set_word_mask;
+- nbit += 32 * parity;
+- for (unsigned i = 0; i < bdescr->bit_.cnt; ++i)
+- {
+- if (bdescr->bit_.bits[i] == nbit)
+- return *this;
+- bdescr->bit_.idx++;
+- } // for
+- BM_ASSERT(0);
+- }
+- return *this;
+- }
+-
+-
+ private:
+ typedef typename iterator_base::block_descr block_descr_type;
+
+- bool decode_wave(block_descr_type* bdescr)
+- {
+- bdescr->bit_.cnt = bm::bitscan_wave(bdescr->bit_.ptr, bdescr->bit_.bits);
+- if (bdescr->bit_.cnt) // found
+- {
+- bdescr->bit_.idx ^= bdescr->bit_.idx; // = 0;
+- bdescr->bit_.pos = this->position_;
+- this->position_ += bdescr->bit_.bits[0];
+- return true;
+- }
+- return false;
+- }
+-
+- bool decode_bit_group(block_descr_type* bdescr)
+- {
+- const word_t* block_end = this->block_ + bm::set_block_size;
+- for (; bdescr->bit_.ptr < block_end;)
+- {
+- if (decode_wave(bdescr))
+- return true;
+- this->position_ += bm::set_bitscan_wave_size * 32; // wave size
+- bdescr->bit_.ptr += bm::set_bitscan_wave_size;
+- } // for
+- return false;
+- }
+-
+- bool decode_bit_group(block_descr_type* bdescr, size_type& rank)
+- {
+- const word_t* block_end = this->block_ + bm::set_block_size;
+-
+- for (; bdescr->bit_.ptr < block_end;)
+- {
+- const bm::id64_t* w64_p = (bm::id64_t*)bdescr->bit_.ptr;
+- bm::id64_t w64 = *w64_p;
+- unsigned cnt = bm::word_bitcount64(w64);
+- if (rank > cnt)
+- {
+- rank -= cnt;
+- }
+- else
+- {
+- if (decode_wave(bdescr))
+- return true;
+- }
+- this->position_ += bm::set_bitscan_wave_size * 32; // wave size
+- bdescr->bit_.ptr += bm::set_bitscan_wave_size;
+- } // for
+- return false;
+- }
++ static bool decode_wave(block_descr_type* bdescr) BMNOEXCEPT;
++ bool decode_bit_group(block_descr_type* bdescr) BMNOEXCEPT;
++ bool decode_bit_group(block_descr_type* bdescr,
++ size_type& rank) BMNOEXCEPT;
++ bool search_in_bitblock() BMNOEXCEPT;
++ bool search_in_gapblock() BMNOEXCEPT;
++ bool search_in_blocks() BMNOEXCEPT;
+
+- bool search_in_bitblock()
+- {
+- BM_ASSERT(this->block_type_ == 0);
+-
+- block_descr_type* bdescr = &(this->bdescr_);
+- bdescr->bit_.ptr = this->block_;
+-
+- return decode_bit_group(bdescr);
+- }
+-
+- bool search_in_gapblock()
+- {
+- BM_ASSERT(this->block_type_ == 1);
+-
+- block_descr_type* bdescr = &(this->bdescr_);
+- bdescr->gap_.ptr = BMGAP_PTR(this->block_);
+- unsigned bitval = *(bdescr->gap_.ptr) & 1;
+-
+- ++(bdescr->gap_.ptr);
+-
+- for (;true;)
+- {
+- unsigned val = *(bdescr->gap_.ptr);
+- if (bitval)
+- {
+- gap_word_t* first = BMGAP_PTR(this->block_) + 1;
+- if (bdescr->gap_.ptr == first)
+- {
+- bdescr->gap_.gap_len = (gap_word_t)(val + 1);
+- }
+- else
+- {
+- bdescr->gap_.gap_len =
+- (gap_word_t)(val - *(bdescr->gap_.ptr-1));
+- }
+- return true;
+- }
+- this->position_ += val + 1;
+- if (val == bm::gap_max_bits - 1)
+- break;
+- bitval ^= 1;
+- ++(bdescr->gap_.ptr);
+- }
+- return false;
+- }
+-
+- bool search_in_blocks()
+- {
+- ++(this->block_idx_);
+- const blocks_manager_type& bman = this->bv_->blockman_;
+- block_idx_type i = this->block_idx_ >> bm::set_array_shift;
+- block_idx_type top_block_size = bman.top_block_size();
+- bm::word_t*** blk_root = bman.top_blocks_root();
+- for (; i < top_block_size; ++i)
+- {
+- bm::word_t** blk_blk = blk_root[i];
+- if (blk_blk == 0)
+- {
+- // fast scan fwd in top level
+- size_type bn = this->block_idx_ + bm::set_sub_array_size;
+- size_type pos = this->position_ + bm::bits_in_array;
+- for (++i; i < top_block_size; ++i)
+- {
+- if (blk_root[i])
+- break;
+- bn += bm::set_sub_array_size;
+- pos += bm::bits_in_array;
+- } // for i
+- this->block_idx_ = bn;
+- this->position_ = pos;
+- if ((i < top_block_size) && blk_root[i])
+- --i;
+- continue;
+- }
+- if ((bm::word_t*)blk_blk == FULL_BLOCK_FAKE_ADDR)
+- blk_blk = FULL_SUB_BLOCK_REAL_ADDR;
+-
+- block_idx_type j = this->block_idx_ & bm::set_array_mask;
+-
+- for(; j < bm::set_sub_array_size; ++j, ++(this->block_idx_))
+- {
+- this->block_ = blk_blk[j];
+-
+- if (this->block_ == 0)
+- {
+- this->position_ += bm::bits_in_block;
+- continue;
+- }
+-
+- this->block_type_ = BM_IS_GAP(this->block_);
+- if (this->block_type_)
+- {
+- if (search_in_gapblock())
+- return true;
+- }
+- else
+- {
+- if (this->block_ == FULL_BLOCK_FAKE_ADDR)
+- this->block_ = FULL_BLOCK_REAL_ADDR;
+- if (search_in_bitblock())
+- return true;
+- }
+- } // for j
+- } // for i
+- return false;
+- }
+ };
+
+ /*!
+@@ -1142,15 +732,14 @@
+ #ifndef BM_NO_STL
+ typedef std::input_iterator_tag iterator_category;
+ #endif
+- counted_enumerator() : bit_count_(0){}
++ counted_enumerator() BMNOEXCEPT : bit_count_(0){}
+
+- counted_enumerator(const enumerator& en) : enumerator(en)
++ counted_enumerator(const enumerator& en) BMNOEXCEPT : enumerator(en)
+ {
+- if (this->valid())
+- bit_count_ = 1;
++ bit_count_ = this->valid(); // 0 || 1
+ }
+
+- counted_enumerator& operator=(const enumerator& en)
++ counted_enumerator& operator=(const enumerator& en) BMNOEXCEPT
+ {
+ enumerator* me = this;
+ *me = en;
+@@ -1159,11 +748,10 @@
+ return *this;
+ }
+
+- counted_enumerator& operator++()
++ counted_enumerator& operator++() BMNOEXCEPT
+ {
+ this->go_up();
+- if (this->valid())
+- ++(this->bit_count_);
++ this->bit_count_ += this->valid();
+ return *this;
+ }
+
+@@ -1171,8 +759,7 @@
+ {
+ counted_enumerator tmp(*this);
+ this->go_up();
+- if (this->valid())
+- ++bit_count_;
++ this->bit_count_ += this->valid();
+ return tmp;
+ }
+
+@@ -1181,7 +768,7 @@
+ Method returns number of ON bits fromn the bit 0 to the current bit
+ For the first bit in bitvector it is 1, for the second 2
+ */
+- size_type count() const { return bit_count_; }
++ size_type count() const BMNOEXCEPT { return bit_count_; }
+ private:
+ /*! Function closed for usage */
+ counted_enumerator& go_to(size_type pos);
+@@ -1198,10 +785,10 @@
+ class mem_pool_guard
+ {
+ public:
+- mem_pool_guard() : bv_(0)
++ mem_pool_guard() BMNOEXCEPT : bv_(0)
+ {}
+
+- mem_pool_guard(allocator_pool_type& pool, bvector<Alloc>& bv)
++ mem_pool_guard(allocator_pool_type& pool, bvector<Alloc>& bv) BMNOEXCEPT
+ : bv_(&bv)
+ {
+ bv.set_allocator_pool(&pool);
+@@ -1213,13 +800,14 @@
+ }
+
+ /// check if vector has no assigned allocator and set one
+- void assign_if_not_set(allocator_pool_type& pool, bvector<Alloc>& bv)
++ void assign_if_not_set(allocator_pool_type& pool,
++ bvector<Alloc>& bv) BMNOEXCEPT
+ {
+- if (bv.get_allocator_pool() == 0) // alloc pool not set yet
++ if (!bv.get_allocator_pool()) // alloc pool not set yet
+ {
+ BM_ASSERT(!bv_);
+ bv_ = &bv;
+- bv.set_allocator_pool(&pool);
++ bv_->set_allocator_pool(&pool);
+ }
+ }
+
+@@ -1248,7 +836,7 @@
+ const gap_word_t* glevel_len;
+
+ allocation_policy(bm::strategy s=BM_BIT,
+- const gap_word_t* glevels = bm::gap_len_table<true>::_len)
++ const gap_word_t* glevels = bm::gap_len_table<true>::_len) BMNOEXCEPT
+ : strat(s), glevel_len(glevels)
+ {}
+ };
+@@ -1329,7 +917,7 @@
+ }
+
+
+- ~bvector() BMNOEXEPT {}
++ ~bvector() BMNOEXCEPT {}
+ /*!
+ \brief Explicit post-construction initialization
+ */
+@@ -1353,7 +941,7 @@
+ /*!
+ \brief Move constructor
+ */
+- bvector(bvector<Alloc>&& bvect) BMNOEXEPT
++ bvector(bvector<Alloc>&& bvect) BMNOEXCEPT
+ {
+ blockman_.move_from(bvect.blockman_);
+ size_ = bvect.size_;
+@@ -1380,7 +968,7 @@
+ /*!
+ \brief Move assignment operator
+ */
+- bvector& operator=(bvector<Alloc>&& bvect) BMNOEXEPT
++ bvector& operator=(bvector<Alloc>&& bvect) BMNOEXCEPT
+ {
+ this->move_from(bvect);
+ return *this;
+@@ -1389,11 +977,11 @@
+ /*!
+ \brief Move bvector content from another bvector
+ */
+- void move_from(bvector<Alloc>& bvect) BMNOEXEPT;
++ void move_from(bvector<Alloc>& bvect) BMNOEXCEPT;
+
+ /*! \brief Exchanges content of bv and this bvector.
+ */
+- void swap(bvector<Alloc>& bvect) BMNOEXEPT;
++ void swap(bvector<Alloc>& bvect) BMNOEXCEPT;
+
+ /*! \brief Merge/move content from another vector
+
+@@ -1419,7 +1007,7 @@
+ return reference(*this, n);
+ }
+
+- bool operator[](size_type n) const
++ bool operator[](size_type n) const BMNOEXCEPT
+ {
+ BM_ASSERT(n < size_);
+ return get_bit(n);
+@@ -1434,25 +1022,23 @@
+ bool operator <= (const bvector<Alloc>& bv) const { return compare(bv)<=0; }
+ bool operator > (const bvector<Alloc>& bv) const { return compare(bv)>0; }
+ bool operator >= (const bvector<Alloc>& bv) const { return compare(bv) >= 0; }
+- bool operator == (const bvector<Alloc>& bv) const { return equal(bv); }
+- bool operator != (const bvector<Alloc>& bv) const { return !equal(bv); }
++ bool operator == (const bvector<Alloc>& bv) const BMNOEXCEPT { return equal(bv); }
++ bool operator != (const bvector<Alloc>& bv) const BMNOEXCEPT { return !equal(bv); }
+
+ bvector<Alloc> operator~() const { return bvector<Alloc>(*this).invert(); }
+
+ Alloc get_allocator() const
+- {
+- return blockman_.get_allocator();
+- }
++ { return blockman_.get_allocator(); }
+
+- /// Set allocator pool for local (non-threaded)
++ /// Set allocator pool for local (non-th readed)
+ /// memory cyclic(lots of alloc-free ops) opertations
+ ///
+- void set_allocator_pool(allocator_pool_type* pool_ptr)
++ void set_allocator_pool(allocator_pool_type* pool_ptr) BMNOEXCEPT
+ { blockman_.get_allocator().set_pool(pool_ptr); }
+
+ /// Get curent allocator pool (if set)
+ /// @return pointer to the current pool or NULL
+- allocator_pool_type* get_allocator_pool()
++ allocator_pool_type* get_allocator_pool() BMNOEXCEPT
+ { return blockman_.get_allocator().get_pool(); }
+
+ // --------------------------------------------------------------------
+@@ -1567,6 +1153,10 @@
+ */
+ void set_bit_no_check(size_type n);
+
++ /**
++ \brief Set specified bit without checking preconditions (size, etc)
++ */
++ bool set_bit_no_check(size_type n, bool val);
+
+ /*!
+ \brief Sets all bits in the specified closed interval [left,right]
+@@ -1596,9 +1186,7 @@
+ @sa set_range
+ */
+ void clear_range(size_type left, size_type right)
+- {
+- set_range(left, right, false);
+- }
++ { set_range(left, right, false); }
+
+
+ /*!
+@@ -1642,20 +1230,13 @@
+ \param free_mem if "true" (default) bvector frees the memory,
+ otherwise sets blocks to 0.
+ */
+- void clear(bool free_mem = false)
+- {
+- blockman_.set_all_zero(free_mem);
+- }
++ void clear(bool free_mem = false) { blockman_.set_all_zero(free_mem); }
+
+ /*!
+ \brief Clears every bit in the bitvector.
+ \return *this;
+ */
+- bvector<Alloc>& reset()
+- {
+- clear(true);
+- return *this;
+- }
++ bvector<Alloc>& reset() { clear(true); return *this; }
+
+ /*!
+ \brief Flips bit n
+@@ -1688,7 +1269,7 @@
+ //size_type capacity() const { return blockman_.capacity(); }
+
+ /*! \brief return current size of the vector (bits) */
+- size_type size() const { return size_; }
++ size_type size() const BMNOEXCEPT { return size_; }
+
+ /*!
+ \brief Change size of the bvector
+@@ -1699,15 +1280,16 @@
+ //@}
+ // --------------------------------------------------------------------
+
+- /*! @name Population counting and ranking methods
++ /*! @name Population counting, ranks, ranges and intervals
+ */
+ //@{
+
+ /*!
+ \brief population cout (count of ON bits)
+- \return Total number of bits ON.
++ \sa count_range
++ \return Total number of bits ON
+ */
+- size_type count() const;
++ size_type count() const BMNOEXCEPT;
+
+ /*! \brief Computes bitcount values for all bvector blocks
+ \param arr - pointer on array of block bit counts
+@@ -1715,8 +1297,9 @@
+ This number +1 gives you number of arr elements initialized during the
+ function call.
+ */
+- block_idx_type count_blocks(unsigned* arr) const;
+-
++ block_idx_type count_blocks(unsigned* arr) const BMNOEXCEPT;
++
++
+ /*!
+ \brief Returns count of 1 bits in the given range [left..right]
+ Uses rank-select index to accelerate the search
+@@ -1729,7 +1312,7 @@
+ */
+ size_type count_range(size_type left,
+ size_type right,
+- const rs_index_type& rs_idx) const;
++ const rs_index_type& rs_idx) const BMNOEXCEPT;
+
+ /*!
+ \brief Returns count of 1 bits in the given range [left..right]
+@@ -1739,11 +1322,33 @@
+
+ \return population count in the diapason
+ */
+- size_type count_range(size_type left,
+- size_type right) const;
++ size_type count_range(size_type left, size_type right) const BMNOEXCEPT;
+
+-
++ /*!
++ \brief Returns true if all bits in the range are 1s (saturated interval)
++ Function uses closed interval [left, right]
+
++ \param left - index of first bit start checking
++ \param right - index of last bit
++
++ \return true if all bits are 1, false otherwise
++ @sa any_range, count_range
++ */
++ bool is_all_one_range(size_type left, size_type right) const BMNOEXCEPT;
++
++ /*!
++ \brief Returns true if any bits in the range are 1s (non-empty interval)
++ Function uses closed interval [left, right]
++
++ \param left - index of first bit start checking
++ \param right - index of last bit
++
++ \return true if at least 1 bits is set
++ @sa is_all_one_range, count_range
++ */
++ bool any_range(size_type left, size_type right) const BMNOEXCEPT;
++
++
+ /*! \brief compute running total of all blocks in bit vector (rank-select index)
+ \param rs_idx - [out] pointer to index / count structure
+ \param bv_blocks - [out] list of block ids in the vector (internal, optional)
+@@ -1762,24 +1367,42 @@
+ should be prepared using build_rs_index
+ \return population count in the range [0..n]
+ \sa build_rs_index
+- \sa count_to_test, select, rank
++ \sa count_to_test, select, rank, rank_corrected
+ */
+- size_type count_to(size_type n, const rs_index_type& rs_idx) const;
++ size_type count_to(size_type n,
++ const rs_index_type& rs_idx) const BMNOEXCEPT;
+
+
+ /*!
+- \brief Returns rank of specified bit position
++ \brief Returns rank of specified bit position (same as count_to())
+
+ \param n - index of bit to rank
+ \param rs_idx - rank-select index
+ \return population count in the range [0..n]
+ \sa build_rs_index
+- \sa count_to_test, select, rank
++ \sa count_to_test, select, rank, rank_corrected
+ */
+- size_type rank(size_type n, const rs_index_type& rs_idx) const
+- { return count_to(n, rs_idx); }
++ size_type rank(size_type n,
++ const rs_index_type& rs_idx) const BMNOEXCEPT
++ { return count_to(n, rs_idx); }
+
++ /*!
++ \brief Returns rank corrceted by the requested border value (as -1)
+
++ This is rank function (bit-count) minus value of bit 'n'
++ if bit-n is true function returns rank()-1 if false returns rank()
++ faster than rank() + test().
++
++
++ \param n - index of bit to rank
++ \param rs_idx - rank-select index
++ \return population count in the range [0..n] corrected as -1 by the value of n
++ \sa build_rs_index
++ \sa count_to_test, select, rank
++ */
++ size_type rank_corrected(size_type n,
++ const rs_index_type& rs_idx) const BMNOEXCEPT;
++
+ /*!
+ \brief popcount in [0..right] range if test(right) == true
+
+@@ -1787,8 +1410,9 @@
+ plus count_to()
+
+ \param n - index of bit to test and rank
+- \param blocks_cnt - block count structure to accelerate search
+- should be prepared using running_count_blocks
++ \param rs_idx - rank-select index
++ (block count structure to accelerate search)
++ should be prepared using build_rs_index()
+
+ \return population count in the diapason or 0 if right bit test failed
+
+@@ -1795,17 +1419,19 @@
+ \sa build_rs_index
+ \sa count_to
+ */
+- size_type count_to_test(size_type n, const rs_index_type& blocks_cnt) const;
++ size_type
++ count_to_test(size_type n,
++ const rs_index_type& rs_idx) const BMNOEXCEPT;
+
+
+ /*! Recalculate bitcount (deprecated)
+ */
+- size_type recalc_count() { return count(); }
++ size_type recalc_count() BMNOEXCEPT { return count(); }
+
+ /*!
+ Disables count cache. (deprecated).
+ */
+- void forget_count() {}
++ void forget_count() BMNOEXCEPT {}
+
+ //@}
+
+@@ -1818,7 +1444,7 @@
+ \param n - Index of the bit to check.
+ \return Bit value (1 or 0)
+ */
+- bool get_bit(size_type n) const;
++ bool get_bit(size_type n) const BMNOEXCEPT;
+
+ /*!
+ \brief returns true if bit n is set and false is bit n is 0.
+@@ -1825,7 +1451,7 @@
+ \param n - Index of the bit to check.
+ \return Bit value (1 or 0)
+ */
+- bool test(size_type n) const { return get_bit(n); }
++ bool test(size_type n) const BMNOEXCEPT { return get_bit(n); }
+
+ //@}
+
+@@ -1874,12 +1500,12 @@
+ \brief Returns true if any bits in this bitset are set, and otherwise returns false.
+ \return true if any bit is set
+ */
+- bool any() const;
++ bool any() const BMNOEXCEPT;
+
+ /*!
+ \brief Returns true if no bits are set, otherwise returns false.
+ */
+- bool none() const { return !any(); }
++ bool none() const BMNOEXCEPT { return !any(); }
+
+ //@}
+ // --------------------------------------------------------------------
+@@ -1890,22 +1516,23 @@
+ /*!
+ \fn bool bvector::find(bm::id_t& pos) const
+ \brief Finds index of first 1 bit
+- \param pos - index of the found 1 bit
++ \param pos - [out] index of the found 1 bit
+ \return true if search returned result
+ \sa get_first, get_next, extract_next, find_reverse, find_first_mismatch
+ */
+- bool find(size_type& pos) const;
++ bool find(size_type& pos) const BMNOEXCEPT;
+
+ /*!
+ \fn bool bvector::find(bm::id_t from, bm::id_t& pos) const
+- \brief Finds index of 1 bit starting from position
++ \brief Find index of 1 bit starting from position
+ \param from - position to start search from
+- \param pos - index of the found 1 bit
++ \param pos - [out] index of the found 1 bit
+ \return true if search returned result
+ \sa get_first, get_next, extract_next, find_reverse, find_first_mismatch
+ */
+- bool find(size_type from, size_type& pos) const;
++ bool find(size_type from, size_type& pos) const BMNOEXCEPT;
+
++
+ /*!
+ \fn bm::id_t bvector::get_first() const
+ \brief find first 1 bit in vector.
+@@ -1915,7 +1542,7 @@
+ \return Index of the first 1 bit, may return 0
+ \sa get_next, find, extract_next, find_reverse
+ */
+- size_type get_first() const { return check_or_next(0); }
++ size_type get_first() const BMNOEXCEPT { return check_or_next(0); }
+
+ /*!
+ \fn bm::id_t bvector::get_next(bm::id_t prev) const
+@@ -1924,7 +1551,7 @@
+ \return Index of the next bit which is ON or 0 if not found.
+ \sa get_first, find, extract_next, find_reverse
+ */
+- size_type get_next(size_type prev) const
++ size_type get_next(size_type prev) const BMNOEXCEPT
+ { return (++prev == bm::id_max) ? 0 : check_or_next(prev); }
+
+ /*!
+@@ -1945,7 +1572,7 @@
+ \return true if search returned result
+ \sa get_first, get_next, extract_next, find, find_first_mismatch
+ */
+- bool find_reverse(size_type& pos) const;
++ bool find_reverse(size_type& pos) const BMNOEXCEPT;
+
+ /*!
+ \brief Finds dynamic range of bit-vector [first, last]
+@@ -1954,7 +1581,7 @@
+ \return true if search returned result
+ \sa get_first, get_next, extract_next, find, find_reverse
+ */
+- bool find_range(size_type& first, size_type& last) const;
++ bool find_range(size_type& first, size_type& last) const BMNOEXCEPT;
+
+ /*!
+ \brief Find bit-vector position for the specified rank(bitcount)
+@@ -1969,7 +1596,8 @@
+
+ \return true if requested rank was found
+ */
+- bool find_rank(size_type rank, size_type from, size_type& pos) const;
++ bool find_rank(size_type rank, size_type from,
++ size_type& pos) const BMNOEXCEPT;
+
+ /*!
+ \brief Find bit-vector position for the specified rank(bitcount)
+@@ -1989,7 +1617,7 @@
+ \return true if requested rank was found
+ */
+ bool find_rank(size_type rank, size_type from, size_type& pos,
+- const rs_index_type& rs_idx) const;
++ const rs_index_type& rs_idx) const BMNOEXCEPT;
+
+ /*!
+ \brief select bit-vector position for the specified rank(bitcount)
+@@ -2007,7 +1635,8 @@
+
+ \return true if requested rank was found
+ */
+- bool select(size_type rank, size_type& pos, const rs_index_type& rs_idx) const;
++ bool select(size_type rank, size_type& pos,
++ const rs_index_type& rs_idx) const BMNOEXCEPT;
+
+ //@}
+
+@@ -2185,7 +1814,7 @@
+
+ @sa statistics
+ */
+- void calc_stat(struct bm::bvector<Alloc>::statistics* st) const;
++ void calc_stat(struct bm::bvector<Alloc>::statistics* st) const BMNOEXCEPT;
+
+ /*!
+ \brief Sets new blocks allocation strategy.
+@@ -2200,7 +1829,8 @@
+ 1 - Blocks mutation mode (adaptive algorithm)
+ \sa set_new_blocks_strat
+ */
+- strategy get_new_blocks_strat() const { return new_blocks_strat_; }
++ strategy get_new_blocks_strat() const BMNOEXCEPT
++ { return new_blocks_strat_; }
+
+ /*!
+ \brief Optimize memory bitvector's memory allocation.
+@@ -2239,7 +1869,7 @@
+ Return true if bvector is initialized at all
+ @internal
+ */
+- bool is_init() const { return blockman_.is_init(); }
++ bool is_init() const BMNOEXCEPT { return blockman_.is_init(); }
+
+ //@}
+
+@@ -2258,13 +1888,13 @@
+ @return 0 if this == arg, -1 if this < arg, 1 if this > arg
+ @sa find_first_mismatch
+ */
+- int compare(const bvector<Alloc>& bvect) const;
++ int compare(const bvector<Alloc>& bvect) const BMNOEXCEPT;
+
+ /*!
+ \brief Equal comparison with an agr bit-vector
+ @return true if vectors are identical
+ */
+- bool equal(const bvector<Alloc>& bvect) const
++ bool equal(const bvector<Alloc>& bvect) const BMNOEXCEPT
+ {
+ size_type pos;
+ bool found = find_first_mismatch(bvect, pos);
+@@ -2285,7 +1915,7 @@
+ bool find_first_mismatch(const bvector<Alloc>& bvect,
+ size_type& pos,
+ size_type search_to = bm::id_max
+- ) const;
++ ) const BMNOEXCEPT;
+
+ //@}
+
+@@ -2305,7 +1935,8 @@
+ Use only if you are BitMagic library
+ @internal
+ */
+- const blocks_manager_type& get_blocks_manager() const { return blockman_; }
++ const blocks_manager_type& get_blocks_manager() const BMNOEXCEPT
++ { return blockman_; }
+
+ /**
+ \brief get access to memory manager (internal)
+@@ -2312,7 +1943,8 @@
+ Use only if you are BitMagic library
+ @internal
+ */
+- blocks_manager_type& get_blocks_manager() { return blockman_; }
++ blocks_manager_type& get_blocks_manager() BMNOEXCEPT
++ { return blockman_; }
+
+ //@}
+
+@@ -2338,21 +1970,22 @@
+
+ private:
+
+- size_type check_or_next(size_type prev) const;
++ size_type check_or_next(size_type prev) const BMNOEXCEPT;
+
+- /// set bit in GAP block withlength extension control
++ /// set bit in GAP block with GAP block length control
+ bool gap_block_set(bm::gap_word_t* gap_blk,
+ bool val, block_idx_type nblock, unsigned nbit);
+-
++
++ /// set bit in GAP block with GAP block length control
++ void gap_block_set_no_ret(bm::gap_word_t* gap_blk,
++ bool val, block_idx_type nblock,
++ unsigned nbit);
++
+ /// check if specified bit is 1, and set it to 0
+ /// if specified bit is 0, scan for the next 1 and returns it
+ /// if no 1 found returns 0
+ size_type check_or_next_extract(size_type prev);
+
+- /**
+- \brief Set specified bit without checking preconditions (size, etc)
+- */
+- bool set_bit_no_check(size_type n, bool val);
+
+ /**
+ \brief AND specified bit without checking preconditions (size, etc)
+@@ -2440,11 +2073,11 @@
+ size_type block_count_to(const bm::word_t* block,
+ block_idx_type nb,
+ unsigned nbit_right,
+- const rs_index_type& blocks_cnt);
++ const rs_index_type& blocks_cnt) BMNOEXCEPT;
+ /**
+ Return value of first bit in the block
+ */
+- bool test_first_block_bit(block_idx_type nb) const;
++ bool test_first_block_bit(block_idx_type nb) const BMNOEXCEPT;
+
+ private:
+ blocks_manager_type blockman_; //!< bitblocks manager
+@@ -2510,7 +2143,7 @@
+ // -----------------------------------------------------------------------
+
+ template<typename Alloc>
+-void bvector<Alloc>::move_from(bvector<Alloc>& bvect) BMNOEXEPT
++void bvector<Alloc>::move_from(bvector<Alloc>& bvect) BMNOEXCEPT
+ {
+ if (this != &bvect)
+ {
+@@ -2572,7 +2205,7 @@
+ // -----------------------------------------------------------------------
+
+ template<typename Alloc>
+-typename bvector<Alloc>::size_type bvector<Alloc>::count() const
++typename bvector<Alloc>::size_type bvector<Alloc>::count() const BMNOEXCEPT
+ {
+ if (!blockman_.is_init())
+ return 0;
+@@ -2592,6 +2225,9 @@
+ if (!found)
+ break;
+ blk_blk = blk_root[i];
++ BM_ASSERT(blk_blk);
++ if (!blk_blk)
++ break;
+ }
+ if ((bm::word_t*)blk_blk == FULL_BLOCK_FAKE_ADDR)
+ {
+@@ -2619,7 +2255,7 @@
+ // -----------------------------------------------------------------------
+
+ template<typename Alloc>
+-bool bvector<Alloc>::any() const
++bool bvector<Alloc>::any() const BMNOEXCEPT
+ {
+ word_t*** blk_root = blockman_.top_blocks_root();
+ if (!blk_root)
+@@ -2780,7 +2416,7 @@
+
+ template<typename Alloc>
+ typename bvector<Alloc>::block_idx_type
+-bvector<Alloc>::count_blocks(unsigned* arr) const
++bvector<Alloc>::count_blocks(unsigned* arr) const BMNOEXCEPT
+ {
+ bm::word_t*** blk_root = blockman_.top_blocks_root();
+ if (blk_root == 0)
+@@ -2797,7 +2433,7 @@
+ bvector<Alloc>::block_count_to(const bm::word_t* block,
+ block_idx_type nb,
+ unsigned nbit_right,
+- const rs_index_type& rs_idx)
++ const rs_index_type& rs_idx) BMNOEXCEPT
+ {
+ size_type c;
+ unsigned sub_range = rs_idx.find_sub_range(nbit_right);
+@@ -2909,7 +2545,7 @@
+ template<typename Alloc>
+ typename bvector<Alloc>::size_type
+ bvector<Alloc>::count_to(size_type right,
+- const rs_index_type& rs_idx) const
++ const rs_index_type& rs_idx) const BMNOEXCEPT
+ {
+ BM_ASSERT(right < bm::id_max);
+ if (!blockman_.is_init())
+@@ -2963,7 +2599,7 @@
+ template<typename Alloc>
+ typename bvector<Alloc>::size_type
+ bvector<Alloc>::count_to_test(size_type right,
+- const rs_index_type& blocks_cnt) const
++ const rs_index_type& rs_idx) const BMNOEXCEPT
+ {
+ BM_ASSERT(right < bm::id_max);
+ if (!blockman_.is_init())
+@@ -2972,15 +2608,13 @@
+ unsigned nblock_right = unsigned(right >> bm::set_block_shift);
+ unsigned nbit_right = unsigned(right & bm::set_block_mask);
+
+- // running count of all blocks before target
+- //
+- size_type cnt = 0;
+ unsigned i, j;
+ bm::get_block_coord(nblock_right, i, j);
+ const bm::word_t* block = blockman_.get_block_ptr(i, j);
+
++ size_type cnt = 0;
+ if (!block)
+- return 0;
++ return cnt;
+
+ bool gap = BM_IS_GAP(block);
+ if (gap)
+@@ -2989,7 +2623,7 @@
+ if (bm::gap_test_unr(gap_blk, (gap_word_t)nbit_right))
+ cnt = bm::gap_bit_count_to(gap_blk, (gap_word_t)nbit_right);
+ else
+- return 0;
++ return cnt;
+ }
+ else
+ {
+@@ -3004,14 +2638,16 @@
+ w &= (1u << (nbit_right & bm::set_word_mask));
+ if (w)
+ {
+- cnt = block_count_to(block, nblock_right, nbit_right, blocks_cnt);
++ cnt = block_count_to(block, nblock_right, nbit_right, rs_idx);
+ BM_ASSERT(cnt == bm::bit_block_calc_count_to(block, nbit_right));
+ }
+ else
+- return 0;
++ {
++ return cnt;
++ }
+ }
+ }
+- cnt += nblock_right ? blocks_cnt.rcount(nblock_right - 1) : 0;
++ cnt += nblock_right ? rs_idx.rcount(nblock_right - 1) : 0;
+ return cnt;
+ }
+
+@@ -3019,14 +2655,59 @@
+
+ template<typename Alloc>
+ typename bvector<Alloc>::size_type
+-bvector<Alloc>::count_range(size_type left, size_type right) const
++bvector<Alloc>::rank_corrected(size_type right,
++ const rs_index_type& rs_idx) const BMNOEXCEPT
+ {
++ BM_ASSERT(right < bm::id_max);
++ if (!blockman_.is_init())
++ return 0;
++
++ unsigned nblock_right = unsigned(right >> bm::set_block_shift);
++ unsigned nbit_right = unsigned(right & bm::set_block_mask);
++
++ size_type cnt = nblock_right ? rs_idx.rcount(nblock_right - 1) : 0;
++
++ unsigned i, j;
++ bm::get_block_coord(nblock_right, i, j);
++ const bm::word_t* block = blockman_.get_block_ptr(i, j);
++
++ if (!block)
++ return cnt;
++
++ bool gap = BM_IS_GAP(block);
++ if (gap)
++ {
++ cnt += bm::gap_bit_count_to(BMGAP_PTR(block), (gap_word_t)nbit_right,
++ true /* rank corrected */);
++ }
++ else
++ {
++ if (block == FULL_BLOCK_FAKE_ADDR)
++ cnt += nbit_right;
++ else
++ {
++ cnt += block_count_to(block, nblock_right, nbit_right, rs_idx);
++ unsigned w = block[nbit_right >> bm::set_word_shift] &
++ (1u << (nbit_right & bm::set_word_mask));
++ cnt -= bool(w); // rank correction
++ }
++ }
++ return cnt;
++}
++
++
++// -----------------------------------------------------------------------
++
++template<typename Alloc>
++typename bvector<Alloc>::size_type
++bvector<Alloc>::count_range(size_type left, size_type right) const BMNOEXCEPT
++{
+ BM_ASSERT(left < bm::id_max && right < bm::id_max);
+- BM_ASSERT(left <= right);
++ if (left > right)
++ bm::xor_swap(left, right);
++ if (right == bm::id_max)
++ --right;
+
+- BM_ASSERT_THROW(right < bm::id_max, BM_ERR_RANGE);
+- BM_ASSERT_THROW(left <= right, BM_ERR_RANGE);
+-
+ if (!blockman_.is_init())
+ return 0;
+
+@@ -3033,8 +2714,8 @@
+ size_type cnt = 0;
+
+ // calculate logical number of start and destination blocks
+- unsigned nblock_left = unsigned(left >> bm::set_block_shift);
+- unsigned nblock_right = unsigned(right >> bm::set_block_shift);
++ block_idx_type nblock_left = (left >> bm::set_block_shift);
++ block_idx_type nblock_right = (right >> bm::set_block_shift);
+
+ unsigned i0, j0;
+ bm::get_block_coord(nblock_left, i0, j0);
+@@ -3076,13 +2757,15 @@
+ {
+ return cnt;
+ }
+-
++
++ // process all full mid-blocks
+ {
+ func.reset();
+ word_t*** blk_root = blockman_.top_blocks_root();
+- unsigned top_blocks_size = blockman_.top_block_size();
++ block_idx_type top_blocks_size = blockman_.top_block_size();
+
+- bm::for_each_nzblock_range(blk_root, top_blocks_size, nblock_left+1, nblock_right-1, func);
++ bm::for_each_nzblock_range(blk_root, top_blocks_size,
++ nblock_left+1, nblock_right-1, func);
+ cnt += func.count();
+ }
+
+@@ -3106,19 +2789,197 @@
+ return cnt;
+ }
+
++// -----------------------------------------------------------------------
+
++template<typename Alloc>
++bool bvector<Alloc>::is_all_one_range(size_type left,
++ size_type right) const BMNOEXCEPT
++{
++ if (!blockman_.is_init())
++ return false; // nothing to do
++
++ if (right < left)
++ bm::xor_swap(left, right);
++ if (right == bm::id_max)
++ --right;
++ if (left == right)
++ return test(left);
++
++ BM_ASSERT(left < bm::id_max && right < bm::id_max);
++
++ block_idx_type nblock_left = (left >> bm::set_block_shift);
++ block_idx_type nblock_right = (right >> bm::set_block_shift);
++
++ unsigned i0, j0;
++ bm::get_block_coord(nblock_left, i0, j0);
++ const bm::word_t* block = blockman_.get_block(i0, j0);
++
++ if (nblock_left == nblock_right) // hit in the same block
++ {
++ unsigned nbit_left = unsigned(left & bm::set_block_mask);
++ unsigned nbit_right = unsigned(right & bm::set_block_mask);
++ return bm::block_is_all_one_range(block, nbit_left, nbit_right);
++ }
++
++ // process entry point block
++ {
++ unsigned nbit_left = unsigned(left & bm::set_block_mask);
++ bool all_one = bm::block_is_all_one_range(block,
++ nbit_left, (bm::gap_max_bits-1));
++ if (!all_one)
++ return all_one;
++ ++nblock_left;
++ }
++
++ // process tail block
++ {
++ bm::get_block_coord(nblock_right, i0, j0);
++ block = blockman_.get_block(i0, j0);
++ unsigned nbit_right = unsigned(right & bm::set_block_mask);
++ bool all_one = bm::block_is_all_one_range(block, 0, nbit_right);
++ if (!all_one)
++ return all_one;
++ --nblock_right;
++ }
++
++ // check all blocks in the middle
++ //
++ if (nblock_left <= nblock_right)
++ {
++ unsigned i_from, j_from, i_to, j_to;
++ bm::get_block_coord(nblock_left, i_from, j_from);
++ bm::get_block_coord(nblock_right, i_to, j_to);
++
++ bm::word_t*** blk_root = blockman_.top_blocks_root();
++
++ for (unsigned i = i_from; i <= i_to; ++i)
++ {
++ bm::word_t** blk_blk = blk_root[i];
++ if (!blk_blk)
++ return false;
++ if ((bm::word_t*)blk_blk == FULL_BLOCK_FAKE_ADDR)
++ continue;
++
++ unsigned j = (i == i_from) ? j_from : 0;
++ unsigned j_limit = (i == i_to) ? j_to+1 : bm::set_sub_array_size;
++ do
++ {
++ bool all_one = bm::check_block_one(blk_blk[j], true);
++ if (!all_one)
++ return all_one;
++ } while (++j < j_limit);
++ } // for i
++ }
++ return true;
++}
++
+ // -----------------------------------------------------------------------
+
+ template<typename Alloc>
++bool bvector<Alloc>::any_range(size_type left, size_type right) const BMNOEXCEPT
++{
++ BM_ASSERT(left < bm::id_max && right < bm::id_max);
++
++ if (!blockman_.is_init())
++ return false; // nothing to do
++
++ if (right < left)
++ bm::xor_swap(left, right);
++ if (right == bm::id_max)
++ --right;
++ if (left == right)
++ return test(left);
++
++ block_idx_type nblock_left = (left >> bm::set_block_shift);
++ block_idx_type nblock_right = (right >> bm::set_block_shift);
++
++ unsigned i0, j0;
++ bm::get_block_coord(nblock_left, i0, j0);
++ const bm::word_t* block = blockman_.get_block(i0, j0);
++
++ if (nblock_left == nblock_right) // hit in the same block
++ {
++ unsigned nbit_left = unsigned(left & bm::set_block_mask);
++ unsigned nbit_right = unsigned(right & bm::set_block_mask);
++ return bm::block_any_range(block, nbit_left, nbit_right);
++ }
++
++ // process entry point block
++ {
++ unsigned nbit_left = unsigned(left & bm::set_block_mask);
++ bool any_one = bm::block_any_range(block,
++ nbit_left, (bm::gap_max_bits-1));
++ if (any_one)
++ return any_one;
++ ++nblock_left;
++ }
++
++ // process tail block
++ {
++ bm::get_block_coord(nblock_right, i0, j0);
++ block = blockman_.get_block(i0, j0);
++ unsigned nbit_right = unsigned(right & bm::set_block_mask);
++ bool any_one = bm::block_any_range(block, 0, nbit_right);
++ if (any_one)
++ return any_one;
++ --nblock_right;
++ }
++
++ // check all blocks in the middle
++ //
++ if (nblock_left <= nblock_right)
++ {
++ unsigned i_from, j_from, i_to, j_to;
++ bm::get_block_coord(nblock_left, i_from, j_from);
++ bm::get_block_coord(nblock_right, i_to, j_to);
++
++ bm::word_t*** blk_root = blockman_.top_blocks_root();
++ {
++ block_idx_type top_size = blockman_.top_block_size();
++ if (i_from >= top_size)
++ return false;
++ if (i_to >= top_size)
++ {
++ i_to = unsigned(top_size-1);
++ j_to = bm::set_sub_array_size-1;
++ }
++ }
++
++ for (unsigned i = i_from; i <= i_to; ++i)
++ {
++ bm::word_t** blk_blk = blk_root[i];
++ if (!blk_blk)
++ continue;
++ if ((bm::word_t*)blk_blk == FULL_BLOCK_FAKE_ADDR)
++ return true;
++
++ unsigned j = (i == i_from) ? j_from : 0;
++ unsigned j_limit = (i == i_to) ? j_to+1 : bm::set_sub_array_size;
++ do
++ {
++ bool any_one = bm::block_any(blk_blk[j]);
++ if (any_one)
++ return any_one;
++ } while (++j < j_limit);
++ } // for i
++ }
++ return false;
++}
++
++// -----------------------------------------------------------------------
++
++template<typename Alloc>
+ typename bvector<Alloc>::size_type
+ bvector<Alloc>::count_range(size_type left,
+ size_type right,
+- const rs_index_type& rs_idx) const
++ const rs_index_type& rs_idx) const BMNOEXCEPT
+ {
+ BM_ASSERT(left <= right);
+
++ if (left > right)
++ bm::xor_swap(left, right);
++
+ BM_ASSERT_THROW(right < bm::id_max, BM_ERR_RANGE);
+- BM_ASSERT_THROW(left <= right, BM_ERR_RANGE);
+
+ if (left == right)
+ return this->test(left);
+@@ -3187,7 +3048,7 @@
+ // -----------------------------------------------------------------------
+
+ template<typename Alloc>
+-bool bvector<Alloc>::get_bit(size_type n) const
++bool bvector<Alloc>::get_bit(size_type n) const BMNOEXCEPT
+ {
+ BM_ASSERT(n < size_);
+ BM_ASSERT_THROW((n < size_), BM_ERR_RANGE);
+@@ -3309,7 +3170,7 @@
+ // -----------------------------------------------------------------------
+
+ template<typename Alloc>
+-int bvector<Alloc>::compare(const bvector<Alloc>& bv) const
++int bvector<Alloc>::compare(const bvector<Alloc>& bv) const BMNOEXCEPT
+ {
+ int res;
+ unsigned top_blocks = blockman_.top_block_size();
+@@ -3429,7 +3290,7 @@
+ template<typename Alloc>
+ bool bvector<Alloc>::find_first_mismatch(
+ const bvector<Alloc>& bvect, size_type& pos,
+- size_type search_to) const
++ size_type search_to) const BMNOEXCEPT
+ {
+ unsigned top_blocks = blockman_.top_block_size();
+ bm::word_t*** top_root = blockman_.top_blocks_root();
+@@ -3531,7 +3392,7 @@
+ // -----------------------------------------------------------------------
+
+ template<typename Alloc>
+-void bvector<Alloc>::swap(bvector<Alloc>& bvect) BMNOEXEPT
++void bvector<Alloc>::swap(bvector<Alloc>& bvect) BMNOEXCEPT
+ {
+ if (this != &bvect)
+ {
+@@ -3543,7 +3404,8 @@
+ // -----------------------------------------------------------------------
+
+ template<typename Alloc>
+-void bvector<Alloc>::calc_stat(struct bvector<Alloc>::statistics* st) const
++void bvector<Alloc>::calc_stat(
++ struct bvector<Alloc>::statistics* st) const BMNOEXCEPT
+ {
+ BM_ASSERT(st);
+
+@@ -3572,6 +3434,9 @@
+ if (!found)
+ break;
+ blk_blk = blk_root[i];
++ BM_ASSERT(blk_blk);
++ if (!blk_blk)
++ break;
+ }
+ if ((bm::word_t*)blk_blk == FULL_BLOCK_FAKE_ADDR)
+ continue;
+@@ -3636,8 +3501,7 @@
+
+ if (block_type) // gap block
+ {
+- bm::gap_word_t* gap_blk = BMGAP_PTR(blk);
+- gap_block_set(gap_blk, val, nblock, nbit);
++ this->gap_block_set_no_ret(BMGAP_PTR(blk), val, nblock, nbit);
+ }
+ else // bit block
+ {
+@@ -3798,7 +3662,10 @@
+ block_idx_type nblock_end = (ids[size_in-1] >> bm::set_block_shift);
+ if (nblock == nblock_end) // special case: one block import
+ {
+- import_block(ids, nblock, 0, stop);
++ if (stop == 1)
++ set_bit_no_check(ids[0]);
++ else
++ import_block(ids, nblock, 0, stop);
+ return;
+ }
+ }
+@@ -3817,7 +3684,11 @@
+ stop = bm::idx_arr_block_lookup_u32(ids, size_in, nblock, start);
+ #endif
+ BM_ASSERT(start < stop);
+- import_block(ids, nblock, start, stop);
++
++ if (stop - start == 1 && n < bm::id_max) // just one bit to set
++ set_bit_no_check(n);
++ else
++ import_block(ids, nblock, start, stop);
+ start = stop;
+ } while (start < size_in);
+ }
+@@ -3826,17 +3697,22 @@
+
+ template<class Alloc>
+ void bvector<Alloc>::import_block(const size_type* ids,
+- block_idx_type nblock,
+- size_type start, size_type stop)
++ block_idx_type nblock,
++ size_type start,
++ size_type stop)
+ {
++ BM_ASSERT(stop > start);
+ int block_type;
+ bm::word_t* blk =
+- blockman_.check_allocate_block(nblock, 1, 0, &block_type, true/*allow NULL ret*/);
++ blockman_.check_allocate_block(nblock, 1, 0, &block_type,
++ true/*allow NULL ret*/);
+ if (!IS_FULL_BLOCK(blk))
+ {
++ // TODO: add a special case when we import just a few bits per block
+ if (BM_IS_GAP(blk))
++ {
+ blk = blockman_.deoptimize_block(nblock); // TODO: try to avoid
+-
++ }
+ #ifdef BM64ADDR
+ bm::set_block_bits_u64(blk, ids, start, stop);
+ #else
+@@ -3867,40 +3743,32 @@
+ return false;
+
+ // calculate word number in block and bit
+- unsigned nbit = unsigned(n & bm::set_block_mask);
+-
++ unsigned nbit = unsigned(n & bm::set_block_mask);
+ if (block_type) // gap
+ {
+- bm::gap_word_t* gap_blk = BMGAP_PTR(blk);
+- unsigned is_set = gap_block_set(gap_blk, val, nblock, nbit);
+- return is_set;
++ return gap_block_set(BMGAP_PTR(blk), val, nblock, nbit);
+ }
+ else // bit block
+ {
+ unsigned nword = unsigned(nbit >> bm::set_word_shift);
+ nbit &= bm::set_word_mask;
+-
+ bm::word_t* word = blk + nword;
+ bm::word_t mask = (((bm::word_t)1) << nbit);
+
+ if (val)
+ {
+- if ( ((*word) & mask) == 0 )
+- {
+- *word |= mask; // set bit
+- return true;
+- }
++ val = ~(*word & mask);
++ *word |= mask; // set bit
++ return val;
+ }
+ else
+ {
+- if ((*word) & mask)
+- {
+- *word &= ~mask; // clear bit
+- return true;
+- }
++ val = ~(*word & mask);
++ *word &= ~mask; // clear bit
++ return val;
+ }
+ }
+- return false;
++ //return false;
+ }
+
+ // -----------------------------------------------------------------------
+@@ -3907,18 +3775,17 @@
+
+ template<class Alloc>
+ bool bvector<Alloc>::gap_block_set(bm::gap_word_t* gap_blk,
+- bool val, block_idx_type nblock, unsigned nbit)
++ bool val, block_idx_type nblock,
++ unsigned nbit)
+ {
+- unsigned is_set, new_block_len;
+- new_block_len =
+- bm::gap_set_value(val, gap_blk, nbit, &is_set);
+- if (is_set)
++ unsigned is_set, new_len, old_len;
++ old_len = bm::gap_length(gap_blk)-1;
++ new_len = bm::gap_set_value(val, gap_blk, nbit, &is_set);
++ if (old_len < new_len)
+ {
+ unsigned threshold = bm::gap_limit(gap_blk, blockman_.glen());
+- if (new_block_len > threshold)
+- {
++ if (new_len > threshold)
+ blockman_.extend_gap_block(nblock, gap_blk);
+- }
+ }
+ return is_set;
+ }
+@@ -3926,6 +3793,24 @@
+ // -----------------------------------------------------------------------
+
+ template<class Alloc>
++void bvector<Alloc>::gap_block_set_no_ret(bm::gap_word_t* gap_blk,
++ bool val, block_idx_type nblock, unsigned nbit)
++{
++ unsigned new_len, old_len;
++ old_len = bm::gap_length(gap_blk)-1;
++ new_len = bm::gap_set_value(val, gap_blk, nbit);
++ if (old_len < new_len)
++ {
++ unsigned threshold = bm::gap_limit(gap_blk, blockman_.glen());
++ if (new_len > threshold)
++ blockman_.extend_gap_block(nblock, gap_blk);
++ }
++}
++
++
++// -----------------------------------------------------------------------
++
++template<class Alloc>
+ bool bvector<Alloc>::inc(size_type n)
+ {
+ // calculate logical block number
+@@ -4089,11 +3974,11 @@
+ //---------------------------------------------------------------------
+
+ template<class Alloc>
+-bool bvector<Alloc>::find(size_type from, size_type& pos) const
++bool bvector<Alloc>::find(size_type from, size_type& pos) const BMNOEXCEPT
+ {
+- BM_ASSERT_THROW(from < bm::id_max, BM_ERR_RANGE);
+-
+- if (from == 0)
++ if (from == bm::id_max)
++ return false;
++ if (!from)
+ {
+ return find(pos);
+ }
+@@ -4104,7 +3989,7 @@
+ //---------------------------------------------------------------------
+
+ template<class Alloc>
+-bool bvector<Alloc>::find_reverse(size_type& pos) const
++bool bvector<Alloc>::find_reverse(size_type& pos) const BMNOEXCEPT
+ {
+ bool found;
+
+@@ -4138,7 +4023,9 @@
+ }
+ if (found)
+ {
+- block_idx_type base_idx = block_idx_type(i) * bm::set_sub_array_size * bm::gap_max_bits;
++ block_idx_type base_idx =
++ block_idx_type(i) * bm::set_sub_array_size *
++ bm::gap_max_bits;
+ base_idx += j * bm::gap_max_bits;
+ pos = base_idx + block_pos;
+ return found;
+@@ -4159,7 +4046,7 @@
+ //---------------------------------------------------------------------
+
+ template<class Alloc>
+-bool bvector<Alloc>::find(size_type& pos) const
++bool bvector<Alloc>::find(size_type& pos) const BMNOEXCEPT
+ {
+ bool found;
+
+@@ -4205,7 +4092,8 @@
+ //---------------------------------------------------------------------
+
+ template<class Alloc>
+-bool bvector<Alloc>::find_range(size_type& in_first, size_type& in_last) const
++bool bvector<Alloc>::find_range(size_type& in_first,
++ size_type& in_last) const BMNOEXCEPT
+ {
+ bool found = find(in_first);
+ if (found)
+@@ -4226,7 +4114,7 @@
+ template<class Alloc>
+ bool bvector<Alloc>::find_rank(size_type rank_in,
+ size_type from,
+- size_type& pos) const
++ size_type& pos) const BMNOEXCEPT
+ {
+ BM_ASSERT_THROW(from < bm::id_max, BM_ERR_RANGE);
+
+@@ -4280,7 +4168,7 @@
+ bool bvector<Alloc>::find_rank(size_type rank_in,
+ size_type from,
+ size_type& pos,
+- const rs_index_type& rs_idx) const
++ const rs_index_type& rs_idx) const BMNOEXCEPT
+ {
+ BM_ASSERT_THROW(from < bm::id_max, BM_ERR_RANGE);
+
+@@ -4349,7 +4237,7 @@
+
+ template<class Alloc>
+ bool bvector<Alloc>::select(size_type rank_in, size_type& pos,
+- const rs_index_type& rs_idx) const
++ const rs_index_type& rs_idx) const BMNOEXCEPT
+ {
+ bool ret = false;
+
+@@ -4385,7 +4273,7 @@
+
+ template<class Alloc>
+ typename bvector<Alloc>::size_type
+-bvector<Alloc>::check_or_next(size_type prev) const
++bvector<Alloc>::check_or_next(size_type prev) const BMNOEXCEPT
+ {
+ if (!blockman_.is_init())
+ return 0;
+@@ -4836,7 +4724,7 @@
+ //---------------------------------------------------------------------
+
+ template<class Alloc>
+-bool bvector<Alloc>::test_first_block_bit(block_idx_type nb) const
++bool bvector<Alloc>::test_first_block_bit(block_idx_type nb) const BMNOEXCEPT
+ {
+ if (nb >= bm::set_total_blocks) // last possible block
+ return false;
+@@ -6529,7 +6417,10 @@
+ BM_ASSERT(gfunc);
+ (*gfunc)(blk, BMGAP_PTR(arg_blk));
+
+- blockman_.optimize_bit_block(nb);
++ // TODO: commented out optimization, because it can be very slow
++ // need to take into account previous operation not to make
++ // fruitless attempts here
++ //blockman_.optimize_bit_block(nb);
+ return;
+ }
+
+@@ -6860,9 +6751,470 @@
+ }
+
+ //---------------------------------------------------------------------
++//
++//---------------------------------------------------------------------
+
++template<class Alloc>
++bool bvector<Alloc>::enumerator::go_up() BMNOEXCEPT
++{
++ BM_ASSERT(this->valid());
+
++ block_descr_type* bdescr = &(this->bdescr_);
++ if (this->block_type_) // GAP
++ {
++ BM_ASSERT(this->block_type_ == 1);
++ ++this->position_;
++ if (--(bdescr->gap_.gap_len))
++ return true;
++ // next gap is "OFF" by definition.
++ if (*(bdescr->gap_.ptr) != bm::gap_max_bits - 1)
++ {
++ gap_word_t prev = *(bdescr->gap_.ptr);
++ unsigned val = *(++(bdescr->gap_.ptr));
++ this->position_ += val - prev;
++ // next gap is now "ON"
++ if (*(bdescr->gap_.ptr) != bm::gap_max_bits - 1)
++ {
++ prev = *(bdescr->gap_.ptr);
++ val = *(++(bdescr->gap_.ptr));
++ bdescr->gap_.gap_len = (gap_word_t)(val - prev);
++ return true; // next "ON" found;
++ }
++ }
++ }
++ else // BIT
++ {
++ unsigned short idx = ++(bdescr->bit_.idx);
++ if (idx < bdescr->bit_.cnt)
++ {
++ this->position_ = bdescr->bit_.pos + bdescr->bit_.bits[idx];
++ return true;
++ }
++ this->position_ +=
++ (bm::set_bitscan_wave_size * 32) - bdescr->bit_.bits[--idx];
++ bdescr->bit_.ptr += bm::set_bitscan_wave_size;
++ if (decode_bit_group(bdescr))
++ return true;
++ }
+
++ if (search_in_blocks())
++ return true;
++
++ this->invalidate();
++ return false;
++}
++
++//---------------------------------------------------------------------
++
++
++template<class Alloc>
++bool bvector<Alloc>::enumerator::skip(size_type rank) BMNOEXCEPT
++{
++ if (!this->valid())
++ return false;
++ if (!rank)
++ return this->valid(); // nothing to do
++
++ for (; rank; --rank)
++ {
++ block_descr_type* bdescr = &(this->bdescr_);
++ switch (this->block_type_)
++ {
++ case 0: // BitBlock
++ for (; rank; --rank)
++ {
++ unsigned short idx = ++(bdescr->bit_.idx);
++ if (idx < bdescr->bit_.cnt)
++ {
++ this->position_ = bdescr->bit_.pos + bdescr->bit_.bits[idx];
++ continue;
++ }
++ this->position_ +=
++ (bm::set_bitscan_wave_size * 32) - bdescr->bit_.bits[--idx];
++ bdescr->bit_.ptr += bm::set_bitscan_wave_size;
++
++ if (!decode_bit_group(bdescr, rank))
++ break;
++ } // for rank
++ break;
++ case 1: // DGAP Block
++ for (; rank; --rank) // TODO: better skip logic
++ {
++ ++this->position_;
++ if (--(bdescr->gap_.gap_len))
++ continue;
++
++ // next gap is "OFF" by definition.
++ if (*(bdescr->gap_.ptr) == bm::gap_max_bits - 1)
++ break;
++ gap_word_t prev = *(bdescr->gap_.ptr);
++ unsigned int val = *(++(bdescr->gap_.ptr));
++
++ this->position_ += val - prev;
++ // next gap is now "ON"
++ if (*(bdescr->gap_.ptr) == bm::gap_max_bits - 1)
++ break;
++ prev = *(bdescr->gap_.ptr);
++ val = *(++(bdescr->gap_.ptr));
++ bdescr->gap_.gap_len = (gap_word_t)(val - prev);
++ } // for rank
++ break;
++ default:
++ BM_ASSERT(0);
++ } // switch
++
++ if (!rank)
++ return true;
++
++ if (!search_in_blocks())
++ {
++ this->invalidate();
++ return false;
++ }
++ } // for rank
++
++ return this->valid();
++}
++
++
++//---------------------------------------------------------------------
++
++
++template<class Alloc>
++bool bvector<Alloc>::enumerator::go_to(size_type pos) BMNOEXCEPT
++{
++ if (pos == 0)
++ {
++ go_first();
++ return this->valid();
++ }
++
++ size_type new_pos = this->bv_->check_or_next(pos); // find the true pos
++ if (!new_pos) // no bits available
++ {
++ this->invalidate();
++ return false;
++ }
++ BM_ASSERT(new_pos >= pos);
++ pos = new_pos;
++
++
++ this->position_ = pos;
++ size_type nb = this->block_idx_ = (pos >> bm::set_block_shift);
++ bm::bvector<Alloc>::blocks_manager_type& bman =
++ this->bv_->get_blocks_manager();
++ unsigned i0, j0;
++ bm::get_block_coord(nb, i0, j0);
++ this->block_ = bman.get_block(i0, j0);
++
++ BM_ASSERT(this->block_);
++
++ this->block_type_ = (bool)BM_IS_GAP(this->block_);
++
++ block_descr_type* bdescr = &(this->bdescr_);
++ unsigned nbit = unsigned(pos & bm::set_block_mask);
++
++ if (this->block_type_) // gap
++ {
++ this->position_ = nb * bm::set_block_size * 32;
++ search_in_gapblock();
++
++ if (this->position_ == pos)
++ return this->valid();
++ this->position_ = pos;
++
++ gap_word_t* gptr = BMGAP_PTR(this->block_);
++ unsigned is_set;
++ unsigned gpos = bm::gap_bfind(gptr, nbit, &is_set);
++ BM_ASSERT(is_set);
++
++ bdescr->gap_.ptr = gptr + gpos;
++ if (gpos == 1)
++ {
++ bdescr->gap_.gap_len = bm::gap_word_t(gptr[gpos] - (nbit - 1));
++ }
++ else
++ {
++ bm::gap_word_t interval = bm::gap_word_t(gptr[gpos] - gptr[gpos - 1]);
++ bm::gap_word_t interval2 = bm::gap_word_t(nbit - gptr[gpos - 1]);
++ bdescr->gap_.gap_len = bm::gap_word_t(interval - interval2 + 1);
++ }
++ }
++ else // bit
++ {
++ if (nbit == 0)
++ {
++ search_in_bitblock();
++ return this->valid();
++ }
++
++ unsigned nword = unsigned(nbit >> bm::set_word_shift);
++
++ // check if we need to step back to match the wave
++ unsigned parity = nword % bm::set_bitscan_wave_size;
++ bdescr->bit_.ptr = this->block_ + (nword - parity);
++ bdescr->bit_.cnt = bm::bitscan_wave(bdescr->bit_.ptr, bdescr->bit_.bits);
++ BM_ASSERT(bdescr->bit_.cnt);
++ bdescr->bit_.pos = (nb * bm::set_block_size * 32) + ((nword - parity) * 32);
++ bdescr->bit_.idx = 0;
++ nbit &= bm::set_word_mask;
++ nbit += 32 * parity;
++ for (unsigned i = 0; i < bdescr->bit_.cnt; ++i)
++ {
++ if (bdescr->bit_.bits[i] == nbit)
++ return this->valid();
++ bdescr->bit_.idx++;
++ } // for
++ BM_ASSERT(0);
++ }
++ return this->valid();
++}
++
++//---------------------------------------------------------------------
++
++template<class Alloc>
++void bvector<Alloc>::enumerator::go_first() BMNOEXCEPT
++{
++ BM_ASSERT(this->bv_);
++
++ blocks_manager_type* bman = &(this->bv_->blockman_);
++ if (!bman->is_init())
++ {
++ this->invalidate();
++ return;
++ }
++
++ bm::word_t*** blk_root = bman->top_blocks_root();
++ this->block_idx_ = this->position_= 0;
++ unsigned i, j;
++
++ for (i = 0; i < bman->top_block_size(); ++i)
++ {
++ bm::word_t** blk_blk = blk_root[i];
++ if (blk_blk == 0) // not allocated
++ {
++ this->block_idx_ += bm::set_sub_array_size;
++ this->position_ += bm::bits_in_array;
++ continue;
++ }
++
++ if ((bm::word_t*)blk_blk == FULL_BLOCK_FAKE_ADDR)
++ blk_blk = FULL_SUB_BLOCK_REAL_ADDR;
++
++ for (j = 0; j < bm::set_sub_array_size; ++j,++(this->block_idx_))
++ {
++ this->block_ = blk_blk[j];
++ if (this->block_ == 0)
++ {
++ this->position_ += bits_in_block;
++ continue;
++ }
++ if (BM_IS_GAP(this->block_))
++ {
++ this->block_type_ = 1;
++ if (search_in_gapblock())
++ return;
++ }
++ else
++ {
++ if (this->block_ == FULL_BLOCK_FAKE_ADDR)
++ this->block_ = FULL_BLOCK_REAL_ADDR;
++ this->block_type_ = 0;
++ if (search_in_bitblock())
++ return;
++ }
++ } // for j
++ } // for i
++
++ this->invalidate();
++}
++
++//---------------------------------------------------------------------
++
++template<class Alloc>
++bool
++bvector<Alloc>::enumerator::decode_wave(block_descr_type* bdescr) BMNOEXCEPT
++{
++ bdescr->bit_.cnt = bm::bitscan_wave(bdescr->bit_.ptr, bdescr->bit_.bits);
++ if (bdescr->bit_.cnt) // found
++ {
++ bdescr->bit_.idx = 0;
++ return true;
++ }
++ return false;
++}
++
++//---------------------------------------------------------------------
++
++template<class Alloc>
++bool
++bvector<Alloc>::enumerator::decode_bit_group(block_descr_type* bdescr) BMNOEXCEPT
++{
++ const word_t* block_end = this->block_ + bm::set_block_size;
++ for (; bdescr->bit_.ptr < block_end;)
++ {
++ if (decode_wave(bdescr))
++ {
++ bdescr->bit_.pos = this->position_;
++ this->position_ += bdescr->bit_.bits[0];
++ return true;
++ }
++ this->position_ += bm::set_bitscan_wave_size * 32; // wave size
++ bdescr->bit_.ptr += bm::set_bitscan_wave_size;
++ } // for
++ return false;
++}
++
++//---------------------------------------------------------------------
++
++template<class Alloc>
++bool
++bvector<Alloc>::enumerator::decode_bit_group(block_descr_type* bdescr,
++ size_type& rank) BMNOEXCEPT
++{
++ const word_t* block_end = this->block_ + bm::set_block_size;
++ for (; bdescr->bit_.ptr < block_end;)
++ {
++ const bm::id64_t* w64_p = (bm::id64_t*)bdescr->bit_.ptr;
++ BM_ASSERT(bm::set_bitscan_wave_size == 4); // TODO: better handle this
++
++ unsigned cnt = bm::word_bitcount64(w64_p[0]);
++ cnt += bm::word_bitcount64(w64_p[1]);
++ if (rank > cnt)
++ {
++ rank -= cnt;
++ }
++ else
++ {
++ if (decode_wave(bdescr))
++ {
++ bdescr->bit_.pos = this->position_;
++ this->position_ += bdescr->bit_.bits[0];
++ return true;
++ }
++ }
++ this->position_ += bm::set_bitscan_wave_size * 32; // wave size
++ bdescr->bit_.ptr += bm::set_bitscan_wave_size;
++ } // for
++ return false;
++}
++
++//---------------------------------------------------------------------
++
++template<class Alloc>
++bool bvector<Alloc>::enumerator::search_in_bitblock() BMNOEXCEPT
++{
++ BM_ASSERT(this->block_type_ == 0);
++
++ block_descr_type* bdescr = &(this->bdescr_);
++ bdescr->bit_.ptr = this->block_;
++ return decode_bit_group(bdescr);
++}
++
++//---------------------------------------------------------------------
++
++template<class Alloc>
++bool bvector<Alloc>::enumerator::search_in_gapblock() BMNOEXCEPT
++{
++ BM_ASSERT(this->block_type_ == 1);
++
++ block_descr_type* bdescr = &(this->bdescr_);
++ bdescr->gap_.ptr = BMGAP_PTR(this->block_);
++ unsigned bitval = *(bdescr->gap_.ptr) & 1;
++
++ ++(bdescr->gap_.ptr);
++
++ for (;true;)
++ {
++ unsigned val = *(bdescr->gap_.ptr);
++ if (bitval)
++ {
++ gap_word_t* first = BMGAP_PTR(this->block_) + 1;
++ if (bdescr->gap_.ptr == first)
++ {
++ bdescr->gap_.gap_len = (gap_word_t)(val + 1);
++ }
++ else
++ {
++ bdescr->gap_.gap_len =
++ (gap_word_t)(val - *(bdescr->gap_.ptr-1));
++ }
++ return true;
++ }
++ this->position_ += val + 1;
++ if (val == bm::gap_max_bits - 1)
++ break;
++ bitval ^= 1;
++ ++(bdescr->gap_.ptr);
++ }
++ return false;
++}
++
++//---------------------------------------------------------------------
++
++template<class Alloc>
++bool bvector<Alloc>::enumerator::search_in_blocks() BMNOEXCEPT
++{
++ ++(this->block_idx_);
++ const blocks_manager_type& bman = this->bv_->blockman_;
++ block_idx_type i = this->block_idx_ >> bm::set_array_shift;
++ block_idx_type top_block_size = bman.top_block_size();
++ bm::word_t*** blk_root = bman.top_blocks_root();
++ for (; i < top_block_size; ++i)
++ {
++ bm::word_t** blk_blk = blk_root[i];
++ if (blk_blk == 0)
++ {
++ // fast scan fwd in top level
++ size_type bn = this->block_idx_ + bm::set_sub_array_size;
++ size_type pos = this->position_ + bm::bits_in_array;
++ for (++i; i < top_block_size; ++i)
++ {
++ if (blk_root[i])
++ break;
++ bn += bm::set_sub_array_size;
++ pos += bm::bits_in_array;
++ } // for i
++ this->block_idx_ = bn;
++ this->position_ = pos;
++ if ((i < top_block_size) && blk_root[i])
++ --i;
++ continue;
++ }
++ if ((bm::word_t*)blk_blk == FULL_BLOCK_FAKE_ADDR)
++ blk_blk = FULL_SUB_BLOCK_REAL_ADDR;
++
++ block_idx_type j = this->block_idx_ & bm::set_array_mask;
++
++ for(; j < bm::set_sub_array_size; ++j, ++(this->block_idx_))
++ {
++ this->block_ = blk_blk[j];
++ if (this->block_ == 0)
++ {
++ this->position_ += bm::bits_in_block;
++ continue;
++ }
++ this->block_type_ = BM_IS_GAP(this->block_);
++ if (this->block_type_)
++ {
++ if (search_in_gapblock())
++ return true;
++ }
++ else
++ {
++ if (this->block_ == FULL_BLOCK_FAKE_ADDR)
++ this->block_ = FULL_BLOCK_REAL_ADDR;
++ if (search_in_bitblock())
++ return true;
++ }
++ } // for j
++ } // for i
++ return false;
++}
++
++//---------------------------------------------------------------------
++
++
+ } // namespace
+
+ #include "bmundef.h"
+Index: c++/include/util/bitset/bmgamma.h
+===================================================================
+--- a/c++/include/util/bitset/bmgamma.h (revision 90103)
++++ b/c++/include/util/bitset/bmgamma.h (revision 90104)
+@@ -42,25 +42,25 @@
+ class gamma_decoder
+ {
+ public:
+- gamma_decoder(TBitIO& bin) : bin_(bin)
++ gamma_decoder(TBitIO& bin) BMNOEXEPT : bin_(bin)
+ {}
+
+ /**
+ Start encoding sequence
+ */
+- void start()
++ void start() BMNOEXEPT
+ {}
+
+ /**
+ Stop decoding sequence
+ */
+- void stop()
++ void stop() BMNOEXEPT
+ {}
+
+ /**
+ Decode word
+ */
+- T operator()(void)
++ T operator()(void) BMNOEXEPT
+ {
+ unsigned l = bin_.eat_zero_bits();
+ bin_.get_bit(); // get border bit
+Index: c++/include/util/bitset/bmaggregator.h
+===================================================================
+--- a/c++/include/util/bitset/bmaggregator.h (revision 90103)
++++ b/c++/include/util/bitset/bmaggregator.h (revision 90104)
+@@ -89,6 +89,7 @@
+
+ public:
+
++ // -----------------------------------------------------------------------
+ /*! @name Construction and setup */
+ //@{
+ aggregator();
+@@ -105,6 +106,12 @@
+ void set_optimization(
+ typename bvector_type::optmode opt = bvector_type::opt_compress)
+ { opt_mode_ = opt; }
++
++ void set_compute_count(bool count_mode)
++ {
++ compute_count_ = count_mode; count_ = 0;
++ }
++
+ //@}
+
+
+@@ -122,12 +129,12 @@
+ @return current arg group size (0 if vector was not added (empty))
+ @sa reset
+ */
+- unsigned add(const bvector_type* bv, unsigned agr_group = 0);
++ unsigned add(const bvector_type* bv, unsigned agr_group = 0) BMNOEXCEPT;
+
+ /**
+ Reset aggregate groups, forget all attached vectors
+ */
+- void reset();
++ void reset() BMNOEXCEPT;
+
+ /**
+ Aggregate added group of vectors using logical OR
+@@ -195,7 +202,9 @@
+ Set search hint for the range, where results needs to be searched
+ (experimental for internal use).
+ */
+- void set_range_hint(size_type from, size_type to);
++ void set_range_hint(size_type from, size_type to) BMNOEXCEPT;
++
++ size_type count() const { return count_; }
+
+ //@}
+
+@@ -305,10 +314,10 @@
+ //@{
+
+ /** Get current operation code */
+- int get_operation() const { return operation_; }
++ int get_operation() const BMNOEXCEPT { return operation_; }
+
+ /** Set operation code for the aggregator */
+- void set_operation(int op_code) { operation_ = op_code; }
++ void set_operation(int op_code) BMNOEXCEPT { operation_ = op_code; }
+
+ /**
+ Prepare operation, create internal resources, analyse dependencies.
+@@ -361,19 +370,20 @@
+ bool init_clear = true);
+
+ static
+- unsigned max_top_blocks(const bvector_type_const_ptr* bv_src, unsigned src_size);
++ unsigned max_top_blocks(const bvector_type_const_ptr* bv_src,
++ unsigned src_size) BMNOEXCEPT;
+
+ bm::word_t* sort_input_blocks_or(const bvector_type_const_ptr* bv_src,
+ unsigned src_size,
+ unsigned i, unsigned j,
+ unsigned* arg_blk_count,
+- unsigned* arg_blk_gap_count);
++ unsigned* arg_blk_gap_count) BMNOEXCEPT;
+
+ bm::word_t* sort_input_blocks_and(const bvector_type_const_ptr* bv_src,
+ unsigned src_size,
+ unsigned i, unsigned j,
+ unsigned* arg_blk_count,
+- unsigned* arg_blk_gap_count);
++ unsigned* arg_blk_gap_count) BMNOEXCEPT;
+
+
+ bool process_bit_blocks_or(blocks_manager_type& bman_target,
+@@ -396,19 +406,24 @@
+ unsigned find_effective_sub_block_size(unsigned i,
+ const bvector_type_const_ptr* bv_src,
+ unsigned src_size,
+- bool top_null_as_zero);
++ bool top_null_as_zero) BMNOEXCEPT;
++
++ static
++ bool any_carry_overs(const unsigned char* carry_overs,
++ unsigned co_size) BMNOEXCEPT;
+
+- bool any_carry_overs(unsigned co_size) const;
+-
+ /**
+ @return carry over
+ */
+- bool process_shift_right_and(const bm::word_t* arg_blk,
+- digest_type& digest,
+- unsigned carry_over);
+-
++ static
++ unsigned process_shift_right_and(bm::word_t* BMRESTRICT blk,
++ const bm::word_t* BMRESTRICT arg_blk,
++ digest_type& BMRESTRICT digest,
++ unsigned carry_over) BMNOEXCEPT;
++
++ static
+ const bm::word_t* get_arg_block(const bvector_type_const_ptr* bv_src,
+- unsigned k, unsigned i, unsigned j);
++ unsigned k, unsigned i, unsigned j) BMNOEXCEPT;
+
+ bvector_type* check_create_target();
+
+@@ -418,8 +433,8 @@
+ /// @internal
+ struct arena
+ {
+- BM_DECLARE_TEMP_BLOCK(tb1);
+- BM_DECLARE_TEMP_BLOCK(tb_opt); ///< temp block for results optimization
++ BM_DECLARE_TEMP_BLOCK(tb1)
++ BM_DECLARE_TEMP_BLOCK(tb_opt) ///< temp block for results optimization
+ const bm::word_t* v_arg_or_blk[max_aggregator_cap]; ///< source blocks list (OR)
+ const bm::gap_word_t* v_arg_or_blk_gap[max_aggregator_cap]; ///< source GAP blocks list (OR)
+ const bm::word_t* v_arg_and_blk[max_aggregator_cap]; ///< source blocks list (AND)
+@@ -450,8 +465,9 @@
+ size_type range_from_ = bm::id_max; ///< search from
+ size_type range_to_ = bm::id_max; ///< search to
+
+- typename bvector_type::optmode opt_mode_;
+-
++ typename bvector_type::optmode opt_mode_; ///< perform search result optimization
++ bool compute_count_; ///< compute search result count
++ size_type count_; ///< search result count
+ };
+
+
+@@ -515,7 +531,9 @@
+
+ template<typename BV>
+ aggregator<BV>::aggregator()
+-: opt_mode_(bvector_type::opt_none)
++: opt_mode_(bvector_type::opt_none),
++ compute_count_(false),
++ count_(0)
+ {
+ ar_ = (arena*) bm::aligned_new_malloc(sizeof(arena));
+ }
+@@ -533,18 +551,19 @@
+ // ------------------------------------------------------------------------
+
+ template<typename BV>
+-void aggregator<BV>::reset()
++void aggregator<BV>::reset() BMNOEXCEPT
+ {
+ arg_group0_size = arg_group1_size = operation_ = top_block_size_ = 0;
+ operation_status_ = op_undefined;
+ range_set_ = false;
+ range_from_ = range_to_ = bm::id_max;
++ count_ = 0;
+ }
+
+ // ------------------------------------------------------------------------
+
+ template<typename BV>
+-void aggregator<BV>::set_range_hint(size_type from, size_type to)
++void aggregator<BV>::set_range_hint(size_type from, size_type to) BMNOEXCEPT
+ {
+ range_from_ = from; range_to_ = to;
+ range_set_ = true;
+@@ -553,11 +572,12 @@
+ // ------------------------------------------------------------------------
+
+ template<typename BV>
+-typename aggregator<BV>::bvector_type* aggregator<BV>::check_create_target()
++typename aggregator<BV>::bvector_type*
++aggregator<BV>::check_create_target()
+ {
+ if (!bv_target_)
+ {
+- bv_target_ = new bvector_type();
++ bv_target_ = new bvector_type(); //TODO: get rid of "new"
+ bv_target_->init();
+ }
+ return bv_target_;
+@@ -566,7 +586,8 @@
+ // ------------------------------------------------------------------------
+
+ template<typename BV>
+-unsigned aggregator<BV>::add(const bvector_type* bv, unsigned agr_group)
++unsigned aggregator<BV>::add(const bvector_type* bv,
++ unsigned agr_group) BMNOEXCEPT
+ {
+ BM_ASSERT_THROW(agr_group <= 1, BM_ERR_RANGE);
+ BM_ASSERT(agr_group <= 1);
+@@ -646,6 +667,7 @@
+ template<typename BV>
+ void aggregator<BV>::combine_shift_right_and(bvector_type& bv_target)
+ {
++ count_ = 0;
+ combine_shift_right_and(bv_target, ar_->arg_bv0, arg_group0_size, false);
+ }
+
+@@ -890,10 +912,11 @@
+
+ template<typename BV>
+ unsigned
+-aggregator<BV>::find_effective_sub_block_size(unsigned i,
+- const bvector_type_const_ptr* bv_src,
+- unsigned src_size,
+- bool top_null_as_zero)
++aggregator<BV>::find_effective_sub_block_size(
++ unsigned i,
++ const bvector_type_const_ptr* bv_src,
++ unsigned src_size,
++ bool top_null_as_zero) BMNOEXCEPT
+ {
+ // quick hack to avoid scanning large, arrays, where such scan can be quite
+ // expensive by itself (this makes this function approximate)
+@@ -924,7 +947,7 @@
+ max_size = j;
+ break;
+ }
+- }
++ } // for j
+ if (max_size == bm::set_sub_array_size - 1)
+ break;
+ } // for k
+@@ -992,8 +1015,6 @@
+ {
+ BM_ASSERT(src_size);
+
+- typename bvector_type::blocks_manager_type& bman_target = bv_target.get_blocks_manager();
+-
+ unsigned arg_blk_count = 0;
+ unsigned arg_blk_gap_count = 0;
+ bm::word_t* blk =
+@@ -1012,12 +1033,11 @@
+ if (ar_->v_arg_and_blk[0] == FULL_BLOCK_REAL_ADDR)
+ {
+ // another nothing to do: one FULL block
++ blocks_manager_type& bman_target = bv_target.get_blocks_manager();
+ bman_target.check_alloc_top_subblock(i);
+ bman_target.set_block_ptr(i, j, blk);
+ if (++j == bm::set_sub_array_size)
+- {
+ bman_target.validate_top_full(i);
+- }
+ return;
+ }
+ }
+@@ -1032,14 +1052,13 @@
+ //
+ if (arg_blk_gap_count)
+ {
+- digest =
+- process_gap_blocks_and(arg_blk_gap_count, digest);
++ digest = process_gap_blocks_and(arg_blk_gap_count, digest);
+ }
+- if (digest) // some results
++ if (digest) // we have results , allocate block and copy from temp
+ {
+- // we have some results, allocate block and copy from temp
++ blocks_manager_type& bman_target = bv_target.get_blocks_manager();
+ bman_target.opt_copy_bit_block(i, j, ar_->tb1,
+- opt_mode_, ar_->tb_opt);
++ opt_mode_, ar_->tb_opt);
+ }
+ }
+ }
+@@ -1154,7 +1173,7 @@
+ bool b = bm::gap_test_unr(ar_->v_arg_and_blk_gap[k], single_bit_idx);
+ if (!b)
+ return 0; // AND 0 causes result to turn 0
+- }
++ } // for k
+ break;
+ }
+ }
+@@ -1471,7 +1490,8 @@
+
+ template<typename BV>
+ unsigned
+-aggregator<BV>::max_top_blocks(const bvector_type_const_ptr* bv_src, unsigned src_size)
++aggregator<BV>::max_top_blocks(const bvector_type_const_ptr* bv_src,
++ unsigned src_size) BMNOEXCEPT
+ {
+ unsigned top_blocks = 1;
+
+@@ -1491,11 +1511,12 @@
+ // ------------------------------------------------------------------------
+
+ template<typename BV>
+-bm::word_t* aggregator<BV>::sort_input_blocks_or(const bvector_type_const_ptr* bv_src,
+- unsigned src_size,
+- unsigned i, unsigned j,
+- unsigned* arg_blk_count,
+- unsigned* arg_blk_gap_count)
++bm::word_t* aggregator<BV>::sort_input_blocks_or(
++ const bvector_type_const_ptr* bv_src,
++ unsigned src_size,
++ unsigned i, unsigned j,
++ unsigned* arg_blk_count,
++ unsigned* arg_blk_gap_count) BMNOEXCEPT
+ {
+ bm::word_t* blk = 0;
+ for (unsigned k = 0; k < src_size; ++k)
+@@ -1529,11 +1550,12 @@
+ // ------------------------------------------------------------------------
+
+ template<typename BV>
+-bm::word_t* aggregator<BV>::sort_input_blocks_and(const bvector_type_const_ptr* bv_src,
+- unsigned src_size,
+- unsigned i, unsigned j,
+- unsigned* arg_blk_count,
+- unsigned* arg_blk_gap_count)
++bm::word_t* aggregator<BV>::sort_input_blocks_and(
++ const bvector_type_const_ptr* bv_src,
++ unsigned src_size,
++ unsigned i, unsigned j,
++ unsigned* arg_blk_count,
++ unsigned* arg_blk_gap_count) BMNOEXCEPT
+ {
+ unsigned full_blk_cnt = 0;
+ bm::word_t* blk = FULL_BLOCK_FAKE_ADDR;
+@@ -1683,7 +1705,7 @@
+ {
+ if (i > top_block_size_)
+ {
+- if (!this->any_carry_overs(src_and_size))
++ if (!any_carry_overs(&ar_->carry_overs_[0], src_and_size))
+ break; // quit early if there is nothing to carry on
+ }
+
+@@ -1690,7 +1712,8 @@
+ unsigned j = 0;
+ do
+ {
+- bool found = combine_shift_right_and(i, j, bv_target, bv_src_and, src_and_size);
++ bool found =
++ combine_shift_right_and(i, j, bv_target, bv_src_and, src_and_size);
+ if (found && any)
+ return found;
+ } while (++j < bm::set_sub_array_size);
+@@ -1697,6 +1720,9 @@
+
+ } // for i
+
++ if (compute_count_)
++ return bool(count_);
++
+ return bv_target.any();
+ }
+
+@@ -1708,7 +1734,6 @@
+ const bvector_type_const_ptr* bv_src,
+ unsigned src_size)
+ {
+- blocks_manager_type& bman_target = bv_target.get_blocks_manager();
+ bm::word_t* blk = temp_blk_ ? temp_blk_ : ar_->tb1;
+ unsigned char* carry_overs = &(ar_->carry_overs_[0]);
+
+@@ -1748,18 +1773,33 @@
+ if (blk_zero) // delayed temp block 0-init requested
+ {
+ bm::bit_block_set(blk, 0);
+- blk_zero = false;
++ blk_zero = !blk_zero; // = false
+ }
+ const bm::word_t* arg_blk = get_arg_block(bv_src, k, i, j);
+- carry_overs[k] = process_shift_right_and(arg_blk, digest, carry_over);
++ carry_overs[k] = (unsigned char)
++ process_shift_right_and(blk, arg_blk, digest, carry_over);
++ BM_ASSERT(carry_overs[k] == 0 || carry_overs[k] == 1);
+ } // for k
+-
++
++ if (blk_zero) // delayed temp block 0-init
++ {
++ bm::bit_block_set(blk, 0);
++ }
+ // block now gets emitted into the target bit-vector
+ if (digest)
+ {
+ BM_ASSERT(!bm::bit_is_all_zero(blk));
+- bman_target.opt_copy_bit_block(i, j, blk,
+- opt_mode_, ar_->tb_opt);
++
++ if (compute_count_)
++ {
++ unsigned cnt = bm::bit_block_count(blk, digest);
++ count_ += cnt;
++ }
++ else
++ {
++ blocks_manager_type& bman_target = bv_target.get_blocks_manager();
++ bman_target.opt_copy_bit_block(i, j, blk, opt_mode_, ar_->tb_opt);
++ }
+ return true;
+ }
+ return false;
+@@ -1768,11 +1808,13 @@
+ // ------------------------------------------------------------------------
+
+ template<typename BV>
+-bool aggregator<BV>::process_shift_right_and(const bm::word_t* arg_blk,
+- digest_type& digest,
+- unsigned carry_over)
++unsigned aggregator<BV>::process_shift_right_and(
++ bm::word_t* BMRESTRICT blk,
++ const bm::word_t* BMRESTRICT arg_blk,
++ digest_type& BMRESTRICT digest,
++ unsigned carry_over) BMNOEXCEPT
+ {
+- bm::word_t* blk = temp_blk_ ? temp_blk_ : ar_->tb1;
++ BM_ASSERT(carry_over == 1 || carry_over == 0);
+
+ if (BM_IS_GAP(arg_blk)) // GAP argument
+ {
+@@ -1800,8 +1842,8 @@
+ if (digest)
+ {
+ carry_over =
+- bm::bit_block_shift_r1_and_unr(blk, carry_over, arg_blk,
+- &digest);
++ bm::bit_block_shift_r1_and_unr(blk, carry_over, arg_blk,
++ &digest);
+ }
+ else // digest == 0
+ {
+@@ -1813,13 +1855,12 @@
+ }
+ else // arg is zero - target block => zero
+ {
+- unsigned co = blk[bm::set_block_size-1] >> 31; // carry out
++ carry_over = blk[bm::set_block_size-1] >> 31; // carry out
+ if (digest)
+ {
+ bm::bit_block_set(blk, 0); // TODO: digest based set
+- digest ^= digest;
++ digest = 0;
+ }
+- carry_over = co;
+ }
+ }
+ return carry_over;
+@@ -1829,22 +1870,26 @@
+
+ template<typename BV>
+ const bm::word_t* aggregator<BV>::get_arg_block(
+- const bvector_type_const_ptr* bv_src,
+- unsigned k, unsigned i, unsigned j)
++ const bvector_type_const_ptr* bv_src,
++ unsigned k, unsigned i, unsigned j) BMNOEXCEPT
+ {
+- const blocks_manager_type& bman_arg = bv_src[k]->get_blocks_manager();
+- return bman_arg.get_block(i, j);
++ return bv_src[k]->get_blocks_manager().get_block(i, j);
+ }
+
+ // ------------------------------------------------------------------------
+
+ template<typename BV>
+-bool aggregator<BV>::any_carry_overs(unsigned co_size) const
++bool aggregator<BV>::any_carry_overs(const unsigned char* carry_overs,
++ unsigned co_size) BMNOEXCEPT
+ {
+- for (unsigned i = 0; i < co_size; ++i)
+- if (ar_->carry_overs_[i])
+- return true;
+- return false;
++ // TODO: loop unroll?
++ unsigned acc = carry_overs[0];
++ for (unsigned i = 1; i < co_size; ++i)
++ acc |= carry_overs[i];
++// if (ar_->carry_overs_[i])
++// return true;
++// return false;
++ return acc;
+ }
+
+ // ------------------------------------------------------------------------
+@@ -1888,7 +1933,7 @@
+ {
+ if (i > top_block_size_)
+ {
+- if (!this->any_carry_overs(arg_group0_size))
++ if (!this->any_carry_overs(&ar_->carry_overs_[0], arg_group0_size))
+ {
+ operation_status_ = op_done;
+ return operation_status_;
+Index: c++/include/util/bitset/bmstrsparsevec.h
+===================================================================
+--- a/c++/include/util/bitset/bmstrsparsevec.h (revision 90103)
++++ b/c++/include/util/bitset/bmstrsparsevec.h (revision 90104)
+@@ -95,19 +95,19 @@
+ {
+ public:
+ const_reference(const str_sparse_vector<CharType, BV, MAX_STR_SIZE>& str_sv,
+- size_type idx) BMNOEXEPT
++ size_type idx) BMNOEXCEPT
+ : str_sv_(str_sv), idx_(idx)
+ {}
+
+- operator const value_type*() const
++ operator const value_type*() const BMNOEXCEPT
+ {
+ str_sv_.get(idx_, buf_, MAX_STR_SIZE);
+ return &(buf_[0]);
+ }
+
+- bool operator==(const const_reference& ref) const
++ bool operator==(const const_reference& ref) const BMNOEXCEPT
+ { return bool(*this) == bool(ref); }
+- bool is_null() const { return str_sv_.is_null(idx_); }
++ bool is_null() const BMNOEXCEPT { return str_sv_.is_null(idx_); }
+ private:
+ const str_sparse_vector<CharType, BV, MAX_STR_SIZE>& str_sv_;
+ size_type idx_;
+@@ -122,11 +122,11 @@
+ {
+ public:
+ reference(str_sparse_vector<CharType, BV, MAX_STR_SIZE>& str_sv,
+- size_type idx) BMNOEXEPT
++ size_type idx) BMNOEXCEPT
+ : str_sv_(str_sv), idx_(idx)
+ {}
+
+- operator const value_type*() const
++ operator const value_type*() const BMNOEXCEPT
+ {
+ str_sv_.get(idx_, buf_, MAX_STR_SIZE);
+ return &(buf_[0]);
+@@ -144,9 +144,9 @@
+ str_sv_.set(idx_, str);
+ return *this;
+ }
+- bool operator==(const reference& ref) const
++ bool operator==(const reference& ref) const BMNOEXCEPT
+ { return bool(*this) == bool(ref); }
+- bool is_null() const { return str_sv_.is_null(idx_); }
++ bool is_null() const BMNOEXCEPT { return str_sv_.is_null(idx_); }
+ private:
+ str_sparse_vector<CharType, BV, MAX_STR_SIZE>& str_sv_;
+ size_type idx_;
+@@ -183,55 +183,56 @@
+ typedef CharType* pointer;
+ typedef CharType*& reference;
+ public:
+- const_iterator();
+- const_iterator(const str_sparse_vector_type* sv);
+- const_iterator(const str_sparse_vector_type* sv, size_type pos);
+- const_iterator(const const_iterator& it);
++ const_iterator() BMNOEXCEPT;
++ const_iterator(const str_sparse_vector_type* sv) BMNOEXCEPT;
++ const_iterator(const str_sparse_vector_type* sv, size_type pos) BMNOEXCEPT;
++ const_iterator(const const_iterator& it) BMNOEXCEPT;
+
+- bool operator==(const const_iterator& it) const
++ bool operator==(const const_iterator& it) const BMNOEXCEPT
+ { return (pos_ == it.pos_) && (sv_ == it.sv_); }
+- bool operator!=(const const_iterator& it) const
++ bool operator!=(const const_iterator& it) const BMNOEXCEPT
+ { return ! operator==(it); }
+- bool operator < (const const_iterator& it) const
++ bool operator < (const const_iterator& it) const BMNOEXCEPT
+ { return pos_ < it.pos_; }
+- bool operator <= (const const_iterator& it) const
++ bool operator <= (const const_iterator& it) const BMNOEXCEPT
+ { return pos_ <= it.pos_; }
+- bool operator > (const const_iterator& it) const
++ bool operator > (const const_iterator& it) const BMNOEXCEPT
+ { return pos_ > it.pos_; }
+- bool operator >= (const const_iterator& it) const
++ bool operator >= (const const_iterator& it) const BMNOEXCEPT
+ { return pos_ >= it.pos_; }
+
+ /// \brief Get current position (value)
+- const value_type* operator*() const { return this->value(); }
++ const value_type* operator*() const BMNOEXCEPT { return this->value(); }
+
+ /// \brief Advance to the next available value
+- const_iterator& operator++() { this->advance(); return *this; }
++ const_iterator& operator++() BMNOEXCEPT
++ { this->advance(); return *this; }
+
+ /// \brief Advance to the next available value
+- const_iterator& operator++(int)
++ const_iterator& operator++(int) BMNOEXCEPT
+ { const_iterator tmp(*this);this->advance(); return tmp; }
+
+
+ /// \brief Get current position (value)
+- const value_type* value() const;
++ const value_type* value() const BMNOEXCEPT;
+
+ /// \brief Get NULL status
+- bool is_null() const { return sv_->is_null(this->pos_); }
++ bool is_null() const BMNOEXCEPT { return sv_->is_null(this->pos_); }
+
+ /// Returns true if iterator is at a valid position
+- bool valid() const { return pos_ != bm::id_max; }
++ bool valid() const BMNOEXCEPT { return pos_ != bm::id_max; }
+
+ /// Invalidate current iterator
+- void invalidate() { pos_ = bm::id_max; }
++ void invalidate() BMNOEXCEPT { pos_ = bm::id_max; }
+
+ /// Current position (index) in the vector
+- size_type pos() const { return pos_; }
++ size_type pos() const BMNOEXCEPT { return pos_; }
+
+ /// re-position to a specified position
+- void go_to(size_type pos);
++ void go_to(size_type pos) BMNOEXCEPT;
+
+ /// advance iterator forward by one
+- void advance();
++ void advance() BMNOEXCEPT;
+
+ protected:
+ typedef bm::heap_matrix<CharType,
+@@ -279,9 +280,9 @@
+ typedef void reference;
+
+ public:
+- back_insert_iterator();
+- back_insert_iterator(str_sparse_vector_type* sv);
+- back_insert_iterator(const back_insert_iterator& bi);
++ back_insert_iterator() BMNOEXCEPT;
++ back_insert_iterator(str_sparse_vector_type* sv) BMNOEXCEPT;
++ back_insert_iterator(const back_insert_iterator& bi) BMNOEXCEPT;
+
+ back_insert_iterator& operator=(const back_insert_iterator& bi)
+ {
+@@ -321,7 +322,7 @@
+ void add_null(size_type count);
+
+ /** return true if insertion buffer is empty */
+- bool empty() const;
++ bool empty() const BMNOEXCEPT;
+
+ /** flush the accumulated buffer */
+ void flush();
+@@ -393,7 +394,7 @@
+ }
+ #ifndef BM_NO_CXX11
+ /*! move-ctor */
+- str_sparse_vector(str_sparse_vector<CharType, BV, MAX_STR_SIZE>&& str_sv) BMNOEXEPT
++ str_sparse_vector(str_sparse_vector<CharType, BV, MAX_STR_SIZE>&& str_sv) BMNOEXCEPT
+ {
+ parent_type::swap(str_sv);
+ remap_flags_ = str_sv.remap_flags_;
+@@ -403,7 +404,7 @@
+
+ /*! move assignmment operator */
+ str_sparse_vector<CharType, BV, MAX_STR_SIZE>& operator =
+- (str_sparse_vector<CharType, BV, MAX_STR_SIZE>&& str_sv) BMNOEXEPT
++ (str_sparse_vector<CharType, BV, MAX_STR_SIZE>&& str_sv) BMNOEXCEPT
+ {
+ if (this != &str_sv)
+ {
+@@ -475,7 +476,8 @@
+
+ @return string length
+ */
+- size_type get(size_type idx, value_type* str, size_type buf_size) const;
++ size_type get(size_type idx,
++ value_type* str, size_type buf_size) const BMNOEXCEPT;
+
+ /*!
+ \brief set specified element with bounds checking and automatic resize
+@@ -568,7 +570,7 @@
+ }
+
+ /*! Swap content */
+- void swap(str_sparse_vector& str_sv) BMNOEXEPT;
++ void swap(str_sparse_vector& str_sv) BMNOEXCEPT;
+
+ ///@}
+
+@@ -589,7 +591,7 @@
+
+ \return 0 - equal, < 0 - vect[i] < str, >0 otherwise
+ */
+- int compare(size_type idx, const value_type* str) const;
++ int compare(size_type idx, const value_type* str) const BMNOEXCEPT;
+
+
+ /**
+@@ -596,7 +598,7 @@
+ \brief Find size of common prefix between two vector elements in octets
+ \return size of common prefix
+ */
+- unsigned common_prefix_length(size_type idx1, size_type idx2) const;
++ unsigned common_prefix_length(size_type idx1, size_type idx2) const BMNOEXCEPT;
+
+ ///@}
+
+@@ -606,7 +608,7 @@
+ ///@{
+
+ /*! \brief resize to zero, free memory */
+- void clear() BMNOEXEPT;
++ void clear() BMNOEXCEPT;
+
+ /*!
+ \brief clear range (assign bit 0 for all plains)
+@@ -650,13 +652,11 @@
+ static size_type max_str() { return sv_octet_plains; }
+
+ /*! \brief get effective string length used in vector
+-
+- Method returns efficiency, how close are we
+- to reserved maximum.
+-
++ Calculate and returns efficiency, how close are we
++ to the reserved maximum.
+ \return current string length maximum
+ */
+- size_type effective_max_str() const;
++ size_type effective_max_str() const BMNOEXCEPT;
+
+ /*! \brief get effective string length used in vector
+ \return current string length maximum
+@@ -691,7 +691,9 @@
+
+ @sa statistics
+ */
+- void calc_stat(struct str_sparse_vector<CharType, BV, MAX_STR_SIZE>::statistics* st) const;
++ void calc_stat(
++ struct str_sparse_vector<CharType, BV, MAX_STR_SIZE>::statistics* st
++ ) const BMNOEXCEPT;
+
+
+ ///@}
+@@ -701,15 +703,15 @@
+ //@{
+
+ /** Provide const iterator access to container content */
+- const_iterator begin() const;
++ const_iterator begin() const BMNOEXCEPT;
+
+ /** Provide const iterator access to the end */
+- const_iterator end() const { return const_iterator(this, bm::id_max); }
++ const_iterator end() const BMNOEXCEPT { return const_iterator(this, bm::id_max); }
+
+ /** Get const_itertor re-positioned to specific element
+ @param idx - position in the sparse vector
+ */
+- const_iterator get_const_iterator(size_type idx) const
++ const_iterator get_const_iterator(size_type idx) const BMNOEXCEPT
+ { return const_iterator(this, idx); }
+
+ /** Provide back insert iterator
+@@ -730,7 +732,7 @@
+ /** \brief trait if sparse vector is "compressed" (false)
+ */
+ static
+- bool is_compressed() { return false; }
++ bool is_compressed() BMNOEXCEPT { return false; }
+
+ ///@}
+
+@@ -745,7 +747,7 @@
+ /**
+ Get remapping status (true|false)
+ */
+- bool is_remap() const { return remap_flags_ != 0; }
++ bool is_remap() const BMNOEXCEPT { return remap_flags_ != 0; }
+
+ /**
+ Build remapping profile and load content from another sparse vector
+@@ -757,7 +759,7 @@
+ Calculate flags which octets are present on each byte-plain.
+ @internal
+ */
+- void calc_octet_stat(plain_octet_matrix_type& octet_matrix) const;
++ void calc_octet_stat(plain_octet_matrix_type& octet_matrix) const BMNOEXCEPT;
+
+ static
+ void build_octet_remap(
+@@ -771,10 +773,11 @@
+ @internal
+ */
+ static
+- bool remap_tosv(value_type* sv_str,
+- size_type buf_size,
+- const value_type* str,
+- const plain_octet_matrix_type& octet_remap_matrix2);
++ bool remap_tosv(value_type* BMRESTRICT sv_str,
++ size_type buf_size,
++ const value_type* BMRESTRICT str,
++ const plain_octet_matrix_type& BMRESTRICT octet_remap_matrix2
++ ) BMNOEXCEPT;
+
+ /*!
+ remap string from external (ASCII) system to matrix internal code
+@@ -782,7 +785,7 @@
+ */
+ bool remap_tosv(value_type* sv_str,
+ size_type buf_size,
+- const value_type* str) const
++ const value_type* str) const BMNOEXCEPT
+ {
+ return remap_tosv(sv_str, buf_size, str, remap_matrix2_);
+ }
+@@ -793,10 +796,12 @@
+ @internal
+ */
+ static
+- bool remap_fromsv(value_type* str,
+- size_type buf_size,
+- const value_type* sv_str,
+- const plain_octet_matrix_type& octet_remap_matrix1);
++ bool remap_fromsv(
++ value_type* BMRESTRICT str,
++ size_type buf_size,
++ const value_type* BMRESTRICT sv_str,
++ const plain_octet_matrix_type& BMRESTRICT octet_remap_matrix1
++ ) BMNOEXCEPT;
+ /*!
+ re-calculate remap matrix2 based on matrix1
+ @internal
+@@ -949,18 +954,18 @@
+ \return true, if it is the same
+ */
+ bool equal(const str_sparse_vector<CharType, BV, MAX_STR_SIZE>& sv,
+- bm::null_support null_able = bm::use_null) const;
++ bm::null_support null_able = bm::use_null) const BMNOEXCEPT;
+
+ /**
+ \brief find position of compressed element by its rank
+ */
+ static
+- bool find_rank(size_type rank, size_type& pos);
++ bool find_rank(size_type rank, size_type& pos) BMNOEXCEPT;
+
+ /**
+ \brief size of sparse vector (may be different for RSC)
+ */
+- size_type effective_size() const { return size(); }
++ size_type effective_size() const BMNOEXCEPT { return size(); }
+
+ protected:
+
+@@ -1138,7 +1143,8 @@
+ //---------------------------------------------------------------------
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+-void str_sparse_vector<CharType, BV, MAX_STR_SIZE>::swap(str_sparse_vector& str_sv) BMNOEXEPT
++void str_sparse_vector<CharType, BV, MAX_STR_SIZE>::swap(
++ str_sparse_vector& str_sv) BMNOEXCEPT
+ {
+ parent_type::swap(str_sv);
+ bm::xor_swap(remap_flags_, str_sv.remap_flags_);
+@@ -1287,7 +1293,7 @@
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+ typename str_sparse_vector<CharType, BV, MAX_STR_SIZE>::size_type
+ str_sparse_vector<CharType, BV, MAX_STR_SIZE>::get(
+- size_type idx, value_type* str, size_type buf_size) const
++ size_type idx, value_type* str, size_type buf_size) const BMNOEXCEPT
+ {
+ size_type i = 0;
+ for (; i < MAX_STR_SIZE; ++i)
+@@ -1330,7 +1336,8 @@
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+ void str_sparse_vector<CharType, BV, MAX_STR_SIZE>::calc_stat(
+- struct str_sparse_vector<CharType, BV, MAX_STR_SIZE>::statistics* st) const
++ struct str_sparse_vector<CharType, BV, MAX_STR_SIZE>::statistics* st
++ ) const BMNOEXCEPT
+ {
+ BM_ASSERT(st);
+ typename bvector_type::statistics stbv;
+@@ -1362,7 +1369,7 @@
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+ int str_sparse_vector<CharType, BV, MAX_STR_SIZE>::compare(
+ size_type idx,
+- const value_type* str) const
++ const value_type* str) const BMNOEXCEPT
+ {
+ BM_ASSERT(str);
+ int res = 0;
+@@ -1390,7 +1397,7 @@
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+ unsigned str_sparse_vector<CharType, BV, MAX_STR_SIZE>::common_prefix_length(
+- size_type idx1, size_type idx2) const
++ size_type idx1, size_type idx2) const BMNOEXCEPT
+ {
+ unsigned i = 0;
+ for (; i < MAX_STR_SIZE; ++i)
+@@ -1416,8 +1423,9 @@
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+ bool
+-str_sparse_vector<CharType, BV, MAX_STR_SIZE>::find_rank(size_type rank,
+- size_type& pos)
++str_sparse_vector<CharType, BV, MAX_STR_SIZE>::find_rank(
++ size_type rank,
++ size_type& pos) BMNOEXCEPT
+ {
+ BM_ASSERT(rank);
+ pos = rank - 1;
+@@ -1428,7 +1436,8 @@
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+ typename str_sparse_vector<CharType, BV, MAX_STR_SIZE>::size_type
+-str_sparse_vector<CharType, BV, MAX_STR_SIZE>::effective_max_str() const
++str_sparse_vector<CharType, BV, MAX_STR_SIZE>::effective_max_str()
++ const BMNOEXCEPT
+ {
+ for (int i = MAX_STR_SIZE-1; i >= 0; --i)
+ {
+@@ -1446,7 +1455,7 @@
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+ void str_sparse_vector<CharType, BV, MAX_STR_SIZE>::calc_octet_stat(
+- plain_octet_matrix_type& octet_matrix) const
++ plain_octet_matrix_type& octet_matrix) const BMNOEXCEPT
+ {
+ octet_matrix.init();
+ octet_matrix.set_zero();
+@@ -1531,10 +1540,10 @@
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+ bool str_sparse_vector<CharType, BV, MAX_STR_SIZE>::remap_tosv(
+- value_type* sv_str,
+- size_type buf_size,
+- const value_type* str,
+- const plain_octet_matrix_type& octet_remap_matrix2)
++ value_type* BMRESTRICT sv_str,
++ size_type buf_size,
++ const value_type* BMRESTRICT str,
++ const plain_octet_matrix_type& BMRESTRICT octet_remap_matrix2) BMNOEXCEPT
+ {
+ for (unsigned i = 0; i < buf_size; ++i)
+ {
+@@ -1559,10 +1568,11 @@
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+ bool str_sparse_vector<CharType, BV, MAX_STR_SIZE>::remap_fromsv(
+- value_type* str,
+- size_type buf_size,
+- const value_type* sv_str,
+- const plain_octet_matrix_type& octet_remap_matrix1)
++ value_type* BMRESTRICT str,
++ size_type buf_size,
++ const value_type* BMRESTRICT sv_str,
++ const plain_octet_matrix_type& BMRESTRICT octet_remap_matrix1
++ ) BMNOEXCEPT
+ {
+ for (unsigned i = 0; i < buf_size; ++i)
+ {
+@@ -1586,7 +1596,8 @@
+ //---------------------------------------------------------------------
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+-void str_sparse_vector<CharType, BV, MAX_STR_SIZE>::remap_from(const str_sparse_vector& str_sv)
++void
++str_sparse_vector<CharType, BV, MAX_STR_SIZE>::remap_from(const str_sparse_vector& str_sv)
+ {
+ if (str_sv.is_remap())
+ {
+@@ -1639,7 +1650,7 @@
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+ bool str_sparse_vector<CharType, BV, MAX_STR_SIZE>::equal(
+ const str_sparse_vector<CharType, BV, MAX_STR_SIZE>& sv,
+- bm::null_support null_able) const
++ bm::null_support null_able) const BMNOEXCEPT
+ {
+ // at this point both vectors should have the same remap settings
+ // to be considered "equal".
+@@ -1686,7 +1697,7 @@
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+ typename str_sparse_vector<CharType, BV, MAX_STR_SIZE>::const_iterator
+-str_sparse_vector<CharType, BV, MAX_STR_SIZE>::begin() const
++str_sparse_vector<CharType, BV, MAX_STR_SIZE>::begin() const BMNOEXCEPT
+ {
+ typedef typename
+ str_sparse_vector<CharType, BV, MAX_STR_SIZE>::const_iterator it_type;
+@@ -1696,7 +1707,7 @@
+ //---------------------------------------------------------------------
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+-void str_sparse_vector<CharType, BV, MAX_STR_SIZE>::clear() BMNOEXEPT
++void str_sparse_vector<CharType, BV, MAX_STR_SIZE>::clear() BMNOEXCEPT
+ {
+ parent_type::clear();
+ }
+@@ -1736,7 +1747,7 @@
+
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+-str_sparse_vector<CharType, BV, MAX_STR_SIZE>::const_iterator::const_iterator()
++str_sparse_vector<CharType, BV, MAX_STR_SIZE>::const_iterator::const_iterator() BMNOEXCEPT
+ : sv_(0), pos_(bm::id_max), pos_in_buf_(~size_type(0))
+ {}
+
+@@ -1744,7 +1755,7 @@
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+ str_sparse_vector<CharType, BV, MAX_STR_SIZE>::const_iterator::const_iterator(
+- const str_sparse_vector<CharType, BV, MAX_STR_SIZE>::const_iterator& it)
++ const str_sparse_vector<CharType, BV, MAX_STR_SIZE>::const_iterator& it) BMNOEXCEPT
+ : sv_(it.sv_), pos_(it.pos_), pos_in_buf_(~size_type(0))
+ {}
+
+@@ -1752,7 +1763,7 @@
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+ str_sparse_vector<CharType, BV, MAX_STR_SIZE>::const_iterator::const_iterator(
+- const str_sparse_vector<CharType, BV, MAX_STR_SIZE>* sv)
++ const str_sparse_vector<CharType, BV, MAX_STR_SIZE>* sv) BMNOEXCEPT
+ : sv_(sv), pos_(sv->empty() ? bm::id_max : 0), pos_in_buf_(~size_type(0))
+ {}
+
+@@ -1761,7 +1772,7 @@
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+ str_sparse_vector<CharType, BV, MAX_STR_SIZE>::const_iterator::const_iterator(
+ const str_sparse_vector<CharType, BV, MAX_STR_SIZE>* sv,
+- typename str_sparse_vector<CharType, BV, MAX_STR_SIZE>::size_type pos)
++ typename str_sparse_vector<CharType, BV, MAX_STR_SIZE>::size_type pos) BMNOEXCEPT
+ : sv_(sv), pos_(pos >= sv->size() ? bm::id_max : pos), pos_in_buf_(~size_type(0))
+ {}
+
+@@ -1769,7 +1780,7 @@
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+ const typename str_sparse_vector<CharType, BV, MAX_STR_SIZE>::value_type*
+-str_sparse_vector<CharType, BV, MAX_STR_SIZE>::const_iterator::value() const
++str_sparse_vector<CharType, BV, MAX_STR_SIZE>::const_iterator::value() const BMNOEXCEPT
+ {
+ BM_ASSERT(sv_);
+ BM_ASSERT(this->valid());
+@@ -1791,8 +1802,10 @@
+ //---------------------------------------------------------------------
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+-void str_sparse_vector<CharType, BV, MAX_STR_SIZE>::const_iterator::go_to(
+- typename str_sparse_vector<CharType, BV, MAX_STR_SIZE>::size_type pos)
++void
++str_sparse_vector<CharType, BV, MAX_STR_SIZE>::const_iterator::go_to(
++ typename str_sparse_vector<CharType, BV, MAX_STR_SIZE>::size_type pos
++ ) BMNOEXCEPT
+ {
+ pos_ = (!sv_ || pos >= sv_->size()) ? bm::id_max : pos;
+ pos_in_buf_ = ~size_type(0);
+@@ -1801,7 +1814,8 @@
+ //---------------------------------------------------------------------
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+-void str_sparse_vector<CharType, BV, MAX_STR_SIZE>::const_iterator::advance()
++void
++str_sparse_vector<CharType, BV, MAX_STR_SIZE>::const_iterator::advance() BMNOEXCEPT
+ {
+ if (pos_ == bm::id_max) // nothing to do, we are at the end
+ return;
+@@ -1825,7 +1839,7 @@
+ //---------------------------------------------------------------------
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+-str_sparse_vector<CharType, BV, MAX_STR_SIZE>::back_insert_iterator::back_insert_iterator()
++str_sparse_vector<CharType, BV, MAX_STR_SIZE>::back_insert_iterator::back_insert_iterator() BMNOEXCEPT
+ : sv_(0), bv_null_(0), pos_in_buf_(~size_type(0)), prev_nb_(0)
+ {}
+
+@@ -1833,7 +1847,7 @@
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+ str_sparse_vector<CharType, BV, MAX_STR_SIZE>::back_insert_iterator::back_insert_iterator(
+- str_sparse_vector<CharType, BV, MAX_STR_SIZE>* sv)
++ str_sparse_vector<CharType, BV, MAX_STR_SIZE>* sv) BMNOEXCEPT
+ : sv_(sv), pos_in_buf_(~size_type(0))
+ {
+ if (sv)
+@@ -1851,7 +1865,7 @@
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+ str_sparse_vector<CharType, BV, MAX_STR_SIZE>::back_insert_iterator::back_insert_iterator(
+-const str_sparse_vector<CharType, BV, MAX_STR_SIZE>::back_insert_iterator& bi)
++const str_sparse_vector<CharType, BV, MAX_STR_SIZE>::back_insert_iterator& bi) BMNOEXCEPT
+ : sv_(bi.sv_), bv_null_(bi.bv_null_), pos_in_buf_(~size_type(0)), prev_nb_(bi.prev_nb_)
+ {
+ BM_ASSERT(bi.empty());
+@@ -1868,7 +1882,9 @@
+ //---------------------------------------------------------------------
+
+ template<class CharType, class BV, unsigned MAX_STR_SIZE>
+-bool str_sparse_vector<CharType, BV, MAX_STR_SIZE>::back_insert_iterator::empty() const
++bool
++str_sparse_vector<CharType, BV, MAX_STR_SIZE>::back_insert_iterator::empty()
++ const BMNOEXCEPT
+ {
+ return (pos_in_buf_ == ~size_type(0) || !sv_);
+ }
projects / ncbi-blast+.git / commitdiff