dense_bitset operator-(const dense_bitset& other) const {
   ASSERT_EQ(size(), other.size());
   dense_bitset ret(size());
   for (size_t i = 0; i < arrlen; ++i) {
     ret.array[i] = array[i] - (array[i] & other.array[i]);
   }
   return ret;
 }

 void new_iteration(int iteration) {
     if (iteration > 0) {
         // Swap
         dense_bitset * tmp = curiteration_bitset;
         curiteration_bitset = nextiteration_bitset;
         nextiteration_bitset = tmp;
         nextiteration_bitset->clear();
     }   
     
 }

 size_t num_tasks() { 
     size_t n = 0;
     for(vid_t i=0; i < curiteration_bitset->size(); i++) {
         n += curiteration_bitset->get(i);
     }
     return n;
 }

 inline void add_task(vid_t vertex, bool also_this_iteration=false) {
     nextiteration_bitset->set_bit(vertex);
     if (also_this_iteration) {
         // If possible, add to schedule already this iteration
         curiteration_bitset->set_bit(vertex);
     }
     has_new_tasks = true;
 }

 size_t operator++(int){
   size_t prevpos = pos;
   if (db->next_bit(pos) == false) pos = (size_t)(-1);
   return prevpos;
 }

 void resize(vid_t maxsize) {
     bitset.resize(maxsize);
 }

 /**
  * Resize the internal locks for a different graph
  */
 void resize(size_t num_vertices) {
   atomic_box_vec.resize(num_vertices);
   atomic_box_vec.clear();
 }

 void clear(size_t i) { atomic_box_vec.clear_bit(i);}

 size_t size() const {
   return atomic_box_vec.size();
 }

 bool peek(const size_t& idx,
                value_type& ret_val) {
   return atomic_box_vec.get(idx);
 }

 bool empty() {
   return (vertex_is_scheduled.popcount() == 0);
 }

 void add_task_to_all() {
     has_new_tasks = true;
     bitset.setall();
 }

 void remove_tasks(vid_t fromvertex, vid_t tovertex) {
     bitset.clear_bits(fromvertex, tovertex);
 }

 inline void remove_task(vid_t vertex) {
     bitset.clear_bit(vertex);
 }

 inline bool is_scheduled(vid_t vertex) {
     return bitset.get(vertex);
 }

 bool test_and_get(const size_t& idx,
                   value_type& ret_val) {
   return atomic_box_vec.clear_bit(idx);
 }

 void resize(vid_t maxsize) {
     curiteration_bitset->resize(maxsize);
     nextiteration_bitset->resize(maxsize);
     
 }

 bool empty(const size_t& idx) const {
   return !atomic_box_vec.get(idx);
 }

 inline bool is_scheduled(vid_t vertex) {
     return curiteration_bitset->get(vertex);
 }

 void remove_tasks(vid_t fromvertex, vid_t tovertex) {
     nextiteration_bitset->clear_bits(fromvertex, tovertex);
 }