//! Swap operator
        void swap(wt_int_rlmn& wt) {
            if (this != &wt) {
                std::swap(m_size, wt.m_size);
                m_bl.swap(wt.m_bl);
                m_bf.swap(wt.m_bf);
                m_wt.swap(wt.m_wt);

                m_bl_rank.swap(wt.m_bl_rank);
                m_bl_rank.set_vector(&m_bl);
                wt.m_bl_rank.set_vector(&(wt.m_bl));
                m_bf_rank.swap(wt.m_bf_rank);
                m_bf_rank.set_vector(&m_bf);
                wt.m_bf_rank.set_vector(&(wt.m_bf));

                m_bl_select.swap(wt.m_bl_select);
                m_bl_select.set_vector(&m_bl);
                wt.m_bl_select.set_vector(&(wt.m_bl));
                m_bf_select.swap(wt.m_bf_select);
                m_bf_select.set_vector(&m_bf);
                wt.m_bf_select.set_vector(&(wt.m_bf));

                m_C.swap(wt.m_C);
                m_C_bf_rank.swap(wt.m_C_bf_rank);
            }
        }

 //! Loads the data structure from the given istream.
 void load(std::istream& in) {
     read_member(m_size, in);
     m_bl.load(in);
     m_bf.load(in);
     m_wt.load(in);
     m_bl_rank.load(in, &m_bl);
     m_bf_rank.load(in, &m_bf);
     m_bl_select.load(in, &m_bl);
     m_bf_select.load(in, &m_bf);
     m_C.load(in);
     m_C_bf_rank.load(in);
 }

 //! Serializes the data structure into the given ostream
 size_type serialize(std::ostream& out, structure_tree_node* v=nullptr, std::string name="")const {
     structure_tree_node* child = structure_tree::add_child(v, name, util::class_name(*this));
     size_type written_bytes = 0;
     written_bytes += write_member(m_size, out, child, "size");
     written_bytes += m_bl.serialize(out, child, "bl");
     written_bytes += m_bf.serialize(out, child, "bf");
     written_bytes += m_wt.serialize(out, child, "wt");
     written_bytes += m_bl_rank.serialize(out, child, "bl_rank");
     written_bytes += m_bf_rank.serialize(out, child, "bf_rank");
     written_bytes += m_bl_select.serialize(out, child, "bl_select");
     written_bytes += m_bf_select.serialize(out, child, "bf_select");
     written_bytes += m_C.serialize(out, child, "C");
     written_bytes += m_C_bf_rank.serialize(out, child, "C_bf_rank");
     structure_tree::add_size(child, written_bytes);
     return written_bytes;
 }

 //! Swap operator
 void swap(int_alphabet& strat) {
     m_char.swap(strat.m_char);
     util::swap_support(m_char_rank, strat.m_char_rank, &m_char, &(strat.m_char));
     util::swap_support(m_char_select, strat.m_char_select, &m_char, &(strat.m_char));
     m_C.swap(strat.m_C);
     std::swap(m_sigma,strat.m_sigma);
 }

 void load(std::istream& in) {
     m_bv.load(in);
     m_bv_select1.load(in);
     m_bv_select1.set_vector(&m_bv);
     m_bv_select0.load(in);
     m_bv_select0.set_vector(&m_bv);
 }

		//! Swap operator
        void swap(succinct_byte_alphabet_strategy& strat){
			m_char.swap(strat.m_char);
			util::swap_support(m_char_rank, strat.m_char_rank, &m_char, &(strat.m_char) );
			util::swap_support(m_char_select, strat.m_char_select, &m_char, &(strat.m_char) );
			m_C.swap(strat.m_C);
			std::swap(m_sigma,strat.m_sigma);
		}

 size_type serialize(std::ostream& out, structure_tree_node* v=nullptr, std::string name="")const {
     structure_tree_node* child = structure_tree::add_child(v, name, util::class_name(*this));
     size_type written_bytes = 0;
     m_bv.serialize(out, child, "bitvector");
     m_bv_select1(out, child, "select1");
     m_bv_select0(out, child, "select0");
     structure_tree::add_size(child, written_bytes);
     return written_bytes;
 }

 //! Load method
 void load(std::istream& in) {
     m_char.load(in);
     m_char_rank.load(in);
     m_char_rank.set_vector(&m_char);
     m_char_select.load(in);
     m_char_select.set_vector(&m_char);
     m_C.load(in);
     read_member(m_sigma, in);
 }

 //! Serialize method
 size_type serialize(std::ostream& out, structure_tree_node* v=nullptr, std::string name="")const {
     structure_tree_node* child = structure_tree::add_child(v, name, util::class_name(*this));
     size_type written_bytes = 0;
     written_bytes += m_char.serialize(out, child, "m_char");
     written_bytes += m_char_rank.serialize(out, child, "m_char_rank");
     written_bytes += m_char_select.serialize(out, child, "m_char_select");
     written_bytes += m_C.serialize(out, child, "m_C");
     written_bytes += write_member(m_sigma, out, child, "m_sigma");
     structure_tree::add_size(child, written_bytes);
     return written_bytes;
 }

        /*! \param i Argument for the length of the prefix v[0..i-1], with \f$0\leq i \leq size()\f$.
           \returns Number of 1-bits in the prefix [0..i-1] of the original bit_vector.
           \par Time complexity
                \f$ \Order{ sample\_rate of the rrr\_vector} \f$
        */
        const size_type rank(size_type i)const {
            assert(m_v != nullptr);
            assert(i <= m_v->size());
            size_type bt_idx = i/t_bs;
            size_type sample_pos = bt_idx/t_k;
            size_type btnrp = m_v->m_btnrp[ sample_pos ];
            size_type rank  = m_v->m_rank[ sample_pos ];
            if (sample_pos+1 < m_v->m_rank.size()) {
                size_type diff_rank  = m_v->m_rank[ sample_pos+1 ] - rank;
#ifndef RRR_NO_OPT
                if (diff_rank == (size_type)0) {
                    return  rank_support_rrr_trait<t_b>::adjust_rank(rank, i);
                } else if (diff_rank == (size_type)t_bs*t_k) {
                    return  rank_support_rrr_trait<t_b>::adjust_rank(
                                rank + i - sample_pos*t_k*t_bs, i);
                }
#endif
            }
            const bool inv = m_v->m_invert[ sample_pos ];
            for (size_type j = sample_pos*t_k; j < bt_idx; ++j) {
                uint16_t r = m_v->m_bt[j];
                rank  += (inv ? t_bs - r: r);
                btnrp += rrr_helper_type::space_for_bt(r);
            }
            uint16_t off = i % t_bs;
            if (!off) {   // needed for special case: if i=size() is a multiple of t_bs
                // the access to m_bt would cause a invalid memory access
                return rank_support_rrr_trait<t_b>::adjust_rank(rank, i);
            }
            uint16_t bt = inv ? t_bs - m_v->m_bt[ bt_idx ] : m_v->m_bt[ bt_idx ];

            uint16_t btnrlen = rrr_helper_type::space_for_bt(bt);
            number_type btnr = rrr_helper_type::decode_btnr(m_v->m_btnr, btnrp, btnrlen);
            uint16_t popcnt  = rrr_helper_type::decode_popcount(bt, btnr, off);
            return rank_support_rrr_trait<t_b>::adjust_rank(rank + popcnt, i);
        }

 const size_type size()const {
     return m_v->size();
 }

 void swap(louds_tree& tree) {
     m_bv.swap(tree.m_bv);
     util::swap_support(m_bv_select1, tree.m_select1, &m_bv, &(tree.m_bv));
     util::swap_support(m_bv_select0, tree.m_select0, &m_bv, &(tree.m_bv));
 }

 /*! \param v A node.
  */
 bool is_leaf(const node_type& v) const {
     // node is the last leaf        or  has no children, so m_bv[v.pos]==1
     return (v.pos+1 == m_bv.size()) or m_bv[v.pos+1];
 }

 //! Returns the number of nodes in the tree.
 size_type nodes()const {
     return  (m_bv.size()+1)/2;
 }

 //! Returns the number of nodes in the tree.
 size_type nodes()const {
     return  m_bv.size()+1/2;
 }