dense_bitset/lib.rs
1//! A dense bitset implementation using only safe code.
2//!
3//! # Examples
4//!
5//! ```
6//! use dense_bitset::BitSet;
7//!
8//! let mut set = BitSet::new();
9//!
10//! set.insert(5);
11//! set.insert(42);
12//! set.insert(7);
13//! assert!(set.get(5));
14//!
15//! assert_eq!(set, [5, 7, 42].iter().collect());
16//! ```
17#[forbid(unsafe_code)]
18use std::{
19 borrow::Borrow,
20 cmp::{Eq, PartialEq},
21 fmt::{self, Write},
22 iter::{DoubleEndedIterator, Extend, FromIterator, FusedIterator},
23 mem,
24};
25
26type Frame = u64;
27
28const FRAME_SIZE: usize = mem::size_of::<Frame>() * 8;
29
30/// A variably sized, heap allocated, dense bitset implemented using no `unsafe` code.
31///
32/// # Examples
33///
34/// ```
35/// use dense_bitset::BitSet;
36///
37/// let mut set = BitSet::new();
38///
39/// set.insert(7);
40/// set.set(4, true);
41/// set.flip(5);
42///
43/// assert_eq!(set, [7, 4, 5].iter().collect());
44///
45/// set.remove(7);
46/// set.flip(4);
47/// set.set(5, false);
48///
49/// assert!(set.is_empty());
50///
51/// let a: BitSet = [2, 5, 12, 17].iter().collect();
52/// let b: BitSet = [2, 12].iter().collect();
53///
54/// assert!(!a.is_disjoint(&b));
55/// assert!(b.is_subset(&a));
56/// assert!(a.is_superset(&b));
57/// ```
58#[derive(Default)]
59pub struct BitSet {
60 inner: Vec<Frame>,
61}
62
63impl fmt::Debug for BitSet {
64 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
65 struct SFmt<'a>(&'a str);
66
67 impl<'a> fmt::Debug for SFmt<'a> {
68 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
69 write!(f, "{}", self.0)
70 }
71 }
72
73 let mut temp = String::new();
74 for frame in self.inner.iter() {
75 write!(temp, "{:01$b}", frame.reverse_bits(), FRAME_SIZE)?;
76 }
77
78 let mut r = temp.trim_end_matches('0');
79 if r.is_empty() {
80 r = "0";
81 }
82
83 f.debug_struct("BitSet").field("inner", &SFmt(r)).finish()
84 }
85}
86
87impl Clone for BitSet {
88 fn clone(&self) -> Self {
89 Self {
90 inner: self.inner.clone(),
91 }
92 }
93
94 fn clone_from(&mut self, source: &Self) {
95 self.inner.clone_from(&source.inner);
96 }
97}
98
99impl PartialEq for BitSet {
100 fn eq(&self, rhs: &Self) -> bool {
101 if self.inner.len() != rhs.inner.len() {
102 false
103 } else {
104 self.inner.iter().zip(rhs.inner.iter()).all(|(a, b)| a == b)
105 }
106 }
107}
108
109impl Eq for BitSet {}
110
111impl BitSet {
112 /// Constructs a new, empty `BitSet`.
113 ///
114 /// # Examples
115 ///
116 /// ```
117 /// # use dense_bitset::BitSet;
118 /// let mut set = BitSet::new();
119 ///
120 /// set.insert(7);
121 /// assert_eq!(1, set.element_count());
122 /// ```
123 pub fn new() -> Self {
124 Self { inner: Vec::new() }
125 }
126
127 /// Constructs a new, empty `BitSet` with at least the specified capacity.
128 /// All indices which are smaller than this capacity,
129 /// can be used without requiring a reallocation.
130 ///
131 /// # Examples
132 ///
133 /// ```
134 /// # use dense_bitset::BitSet;
135 /// let mut set = BitSet::with_capacity(100);
136 /// let capacity = set.capacity();
137 /// assert!(capacity >= 100);
138 /// set.insert(99);
139 /// assert_eq!(capacity, set.capacity());
140 /// ```
141 pub fn with_capacity(capacity: usize) -> Self {
142 let frames = if capacity % FRAME_SIZE == 0 {
143 capacity / FRAME_SIZE
144 } else {
145 capacity / FRAME_SIZE + 1
146 };
147
148 Self {
149 inner: Vec::with_capacity(frames),
150 }
151 }
152
153 /// Removes all trailing frames containing `0`.
154 #[inline]
155 fn remove_empty_frames(&mut self) {
156 while self.inner.last().map_or(false, |&l| l == 0) {
157 self.inner.pop();
158 }
159 }
160
161 /// Returns the capacity of this `BitSet`.
162 /// All indices which are smaller than this capacity,
163 /// can be used without requiring a reallocation.
164 ///
165 /// # Examples
166 ///
167 /// ```
168 /// # use dense_bitset::BitSet;
169 /// let mut set = BitSet::with_capacity(100);
170 /// assert!(set.capacity() >= 100);
171 /// ```
172 pub fn capacity(&self) -> usize {
173 self.inner.capacity() * FRAME_SIZE
174 }
175
176 /// Returns `true` if no entries are set to `false`.
177 ///
178 /// # Examples
179 ///
180 /// ```
181 /// # use dense_bitset::BitSet;
182 /// let mut set = BitSet::new();
183 /// assert!(set.is_empty());
184 ///
185 /// set.insert(99);
186 /// assert!(!set.is_empty());
187 ///
188 /// set.remove(99);
189 /// assert!(set.is_empty());
190 /// ```
191 pub fn is_empty(&self) -> bool {
192 self.inner.iter().all(|&frame| frame == 0)
193 }
194
195 /// Returns the amount of entries set to `true`.
196 ///
197 /// # Examples
198 ///
199 /// ```
200 /// # use dense_bitset::BitSet;
201 /// let mut set = BitSet::new();
202 /// assert_eq!(0, set.element_count());
203 ///
204 /// set.insert(1729);
205 /// set.insert(1337);
206 /// assert_eq!(2, set.element_count());
207 /// ```
208 pub fn element_count(&self) -> usize {
209 self.inner
210 .iter()
211 .fold(0, |sum, elem| sum + elem.count_ones() as usize)
212 }
213
214 /// Shrinks the `capacity` as much as possible.
215 ///
216 /// While the `capacity` will drop down as close as possible to the biggest set `idx`,
217 /// there might still be space for a few more elements.
218 ///
219 /// # Examples
220 ///
221 /// ```
222 /// # use dense_bitset::BitSet;
223 /// let mut set = BitSet::with_capacity(1000);
224 /// set.extend([100, 200, 300].iter());
225 /// assert!(set.capacity() >= 1000);
226 ///
227 /// set.shrink_to_fit();
228 /// assert!(set.capacity() > 300);
229 /// ```
230 pub fn shrink_to_fit(&mut self) {
231 self.inner.shrink_to_fit();
232 }
233
234 /// Sets the entry at `idx` to `value`.
235 ///
236 /// # Examples
237 ///
238 /// ```
239 /// # use dense_bitset::BitSet;
240 /// let mut set = BitSet::new();
241 ///
242 /// set.set(1337, true);
243 /// assert_eq!(true, set.get(1337));
244 ///
245 /// set.set(1337, false);
246 /// assert_eq!(false, set.get(1337));
247 /// ```
248 pub fn set(&mut self, idx: usize, value: bool) {
249 if value {
250 self.insert(idx)
251 } else {
252 self.remove(idx)
253 }
254 }
255
256 /// Sets the entry at `idx` to `true`.
257 ///
258 /// # Examples
259 ///
260 /// ```
261 /// # use dense_bitset::BitSet;
262 /// let mut set = BitSet::new();
263 ///
264 /// set.insert(69);
265 /// assert_eq!(true, set.get(69));
266 ///
267 /// set.remove(69);
268 /// assert_eq!(false, set.get(69));
269 /// ```
270 pub fn insert(&mut self, idx: usize) {
271 let frame_offset = idx / FRAME_SIZE;
272 if frame_offset >= self.inner.len() {
273 self.inner.resize(frame_offset + 1, 0);
274 }
275
276 self.inner[frame_offset] |= 1 << idx - frame_offset * FRAME_SIZE;
277 }
278
279 /// Sets the entry at `idx` to `false`.
280 ///
281 /// # Examples
282 ///
283 /// ```
284 /// # use dense_bitset::BitSet;
285 /// let mut set = BitSet::new();
286 ///
287 /// set.insert(42);
288 /// assert_eq!(true, set.get(42));
289 ///
290 /// set.remove(42);
291 /// assert_eq!(false, set.get(42));
292 /// ```
293 pub fn remove(&mut self, idx: usize) {
294 let frame_offset = idx / FRAME_SIZE;
295 if frame_offset < self.inner.len() {
296 self.inner[frame_offset] &= !(1 << idx - frame_offset * FRAME_SIZE);
297 }
298
299 self.remove_empty_frames();
300 }
301
302 /// Inverts the value of the entry at `idx`.
303 ///
304 /// # Examples
305 ///
306 /// ```
307 /// # use dense_bitset::BitSet;
308 /// let mut set = BitSet::new();
309 /// assert_eq!(false, set.get(42));
310 ///
311 /// set.flip(42);
312 /// assert_eq!(true, set.get(42));
313 ///
314 /// set.flip(42);
315 /// assert_eq!(false, set.get(42));
316 /// ```
317 pub fn flip(&mut self, idx: usize) {
318 let frame_offset = idx / FRAME_SIZE;
319 if frame_offset >= self.inner.len() {
320 self.inner.resize(frame_offset + 1, 0);
321 }
322
323 self.inner[frame_offset] ^= 1 << idx - frame_offset * FRAME_SIZE;
324 self.remove_empty_frames();
325 }
326
327 /// Returns the value of the entry at `idx`.
328 ///
329 /// # Examples
330 ///
331 /// ```
332 /// # use dense_bitset::BitSet;
333 /// let mut set = BitSet::new();
334 /// assert_eq!(false, set.get(7));
335 ///
336 /// set.insert(6);
337 /// assert_eq!(false, set.get(7));
338 ///
339 /// set.insert(7);
340 /// assert_eq!(true, set.get(7));
341 /// ```
342 pub fn get(&self, idx: usize) -> bool {
343 let frame_offset = idx / FRAME_SIZE;
344 self.inner
345 .get(frame_offset)
346 .map_or(false, |v| v & (1 << idx - frame_offset * FRAME_SIZE) != 0)
347 }
348
349 /// Returns if `self` and `other` do not share a `true` element with the same index.
350 /// This is equivalent to checking for an empty intersection.
351 ///
352 /// # Examples
353 ///
354 /// ```
355 /// # use dense_bitset::BitSet;
356 /// let a: BitSet = [1, 2, 3].iter().collect();
357 /// let mut b = BitSet::new();
358 ///
359 /// assert_eq!(a.is_disjoint(&b), true);
360 /// b.insert(4);
361 /// assert_eq!(a.is_disjoint(&b), true);
362 /// b.insert(1);
363 /// assert_eq!(a.is_disjoint(&b), false);
364 /// ```
365 pub fn is_disjoint(&self, other: &BitSet) -> bool {
366 self.inner
367 .iter()
368 .zip(other.inner.iter())
369 .all(|(a, b)| a & b == 0)
370 }
371
372 /// Returns `true` if the set is a subset of `other`,
373 /// meaning `other` contains at least all the values in `self`.
374 ///
375 /// # Examples
376 ///
377 /// ```
378 /// # use dense_bitset::BitSet;
379 /// let sup: BitSet = [1, 2, 3].iter().collect();
380 /// let mut set = BitSet::new();
381 ///
382 /// assert_eq!(set.is_subset(&sup), true);
383 /// set.insert(2);
384 /// assert_eq!(set.is_subset(&sup), true);
385 /// set.insert(4);
386 /// assert_eq!(set.is_subset(&sup), false);
387 /// ```
388 pub fn is_subset(&self, other: &BitSet) -> bool {
389 if self.inner.len() <= other.inner.len() {
390 self.inner
391 .iter()
392 .zip(other.inner.iter())
393 .all(|(a, b)| a & !b == 0)
394 } else {
395 false
396 }
397 }
398
399 /// Returns `true` if `self` is a superset of `other`,
400 /// meaning `self` contains at least all the values in `other`.
401 ///
402 /// # Examples
403 ///
404 /// ```
405 /// # use dense_bitset::BitSet;
406 /// let sup: BitSet = [1, 2].iter().collect();
407 /// let mut set = BitSet::new();
408 ///
409 /// assert_eq!(set.is_superset(&sup), false);
410 ///
411 /// set.insert(0);
412 /// set.insert(1);
413 /// assert_eq!(set.is_superset(&sup), false);
414 ///
415 /// set.insert(2);
416 /// assert_eq!(set.is_superset(&sup), true);
417 /// ```
418 #[inline]
419 pub fn is_superset(&self, other: &BitSet) -> bool {
420 other.is_subset(self)
421 }
422
423 /// Returns the highest index for which the entry which is set to `true`.
424 /// In case there is no `true` entry, this method returns `None`.
425 ///
426 /// # Examples
427 ///
428 /// ```rust
429 /// # use dense_bitset::BitSet;
430 /// let mut set = BitSet::new();
431 /// assert_eq!(None, set.highest_bit());
432 ///
433 /// set.insert(3);
434 /// set.insert(7);
435 /// set.insert(4);
436 /// assert_eq!(Some(7), set.highest_bit());
437 /// ```
438 pub fn highest_bit(&self) -> Option<usize> {
439 self.iter().next_back()
440 }
441
442 /// Returns the lowest index for which the entry is set to `true`.
443 /// In case there is no `true` entry, this method returns `None`.
444 ///
445 /// # Examples
446 ///
447 /// ```rust
448 /// # use dense_bitset::BitSet;
449 /// let mut set = BitSet::new();
450 /// assert_eq!(None, set.lowest_bit());
451 ///
452 /// set.insert(3);
453 /// set.insert(7);
454 /// set.insert(4);
455 /// assert_eq!(Some(3), set.lowest_bit());
456 /// ```
457 pub fn lowest_bit(&self) -> Option<usize> {
458 self.iter().next()
459 }
460
461 /// Returns an iterator over the bitset which returns all indices of entries set to `true`.
462 /// The indices are sorted from lowest to highest.
463 ///
464 /// # Examples
465 ///
466 /// ```
467 /// # use dense_bitset::BitSet;
468 /// let set: BitSet = [1, 12, 19, 4].iter().copied().collect();
469 /// let mut iter = set.iter();
470 ///
471 /// assert_eq!(Some(1), iter.next());
472 /// assert_eq!(Some(4), iter.next());
473 /// assert_eq!(Some(12), iter.next());
474 /// assert_eq!(Some(19), iter.next());
475 /// assert_eq!(None, iter.next());
476 /// ```
477 pub fn iter(&self) -> IdxIter<&Self> {
478 IdxIter {
479 inner: self,
480 pos: 0,
481 end_pos: self.inner.len() * FRAME_SIZE,
482 }
483 }
484}
485
486impl<'a> Extend<&'a usize> for BitSet {
487 fn extend<I: IntoIterator<Item = &'a usize>>(&mut self, iter: I) {
488 for item in iter {
489 self.insert(*item);
490 }
491 }
492}
493
494impl Extend<usize> for BitSet {
495 fn extend<I: IntoIterator<Item = usize>>(&mut self, iter: I) {
496 for item in iter {
497 self.insert(item);
498 }
499 }
500}
501
502impl<'a> FromIterator<&'a bool> for BitSet {
503 #[inline]
504 fn from_iter<U: IntoIterator<Item = &'a bool>>(iter: U) -> BitSet {
505 Self::from_iter(iter.into_iter().copied())
506 }
507}
508
509impl FromIterator<bool> for BitSet {
510 fn from_iter<U: IntoIterator<Item = bool>>(iter: U) -> BitSet {
511 let mut set = BitSet::new();
512 for (idx, value) in iter.into_iter().enumerate() {
513 if value {
514 set.insert(idx);
515 }
516 }
517
518 set
519 }
520}
521
522impl<'a> FromIterator<&'a usize> for BitSet {
523 #[inline]
524 fn from_iter<U: IntoIterator<Item = &'a usize>>(iter: U) -> BitSet {
525 Self::from_iter(iter.into_iter().copied())
526 }
527}
528
529impl FromIterator<usize> for BitSet {
530 fn from_iter<U: IntoIterator<Item = usize>>(iter: U) -> BitSet {
531 let mut set = BitSet::new();
532 for idx in iter {
533 set.insert(idx);
534 }
535 set
536 }
537}
538
539impl IntoIterator for BitSet {
540 type Item = usize;
541 type IntoIter = IdxIter<BitSet>;
542
543 fn into_iter(self) -> IdxIter<BitSet> {
544 let end_pos = self.inner.len() * FRAME_SIZE;
545
546 IdxIter {
547 inner: self,
548 pos: 0,
549 end_pos,
550 }
551 }
552}
553
554/// A iterator over the `true` entries of a `BitSet`.
555///
556/// This struct is created by calling [`BitSet::iter`].
557///
558/// # Examples
559///
560/// ```
561/// # use dense_bitset::BitSet;
562/// use dense_bitset::IdxIter;
563///
564/// let set: BitSet = [4, 3, 12, 19].iter().collect();
565///
566/// let mut ref_iter = set.iter();
567/// assert!([3, 4, 12, 19].iter().all(|&e| e == ref_iter.next().unwrap()));
568/// assert_eq!(None, ref_iter.next());
569///
570/// let mut owned_iter = set.into_iter();
571/// assert!([3, 4, 12, 19].iter().all(|&e| e == owned_iter.next().unwrap()));
572/// assert_eq!(None, owned_iter.next());
573/// ```
574/// [`BitSet::iter`]: ./struct.BitSet.html#method.iter
575pub struct IdxIter<B> {
576 inner: B,
577 pos: usize,
578 end_pos: usize,
579}
580
581impl<B: Borrow<BitSet>> Iterator for IdxIter<B> {
582 type Item = usize;
583
584 fn next(&mut self) -> Option<usize> {
585 while self.pos <= self.end_pos {
586 let pos = self.pos;
587 self.pos += 1;
588 if self.inner.borrow().get(pos) {
589 return Some(pos);
590 }
591 }
592 None
593 }
594}
595
596impl<B: Borrow<BitSet>> DoubleEndedIterator for IdxIter<B> {
597 fn next_back(&mut self) -> Option<usize> {
598 while self.end_pos > self.pos {
599 let pos = self.end_pos;
600 self.end_pos -= 1;
601 if self.inner.borrow().get(pos) {
602 return Some(pos);
603 }
604 }
605
606 if self.end_pos == self.pos {
607 self.pos += 1;
608 if self.inner.borrow().get(self.end_pos) {
609 return Some(self.end_pos);
610 }
611 }
612
613 None
614 }
615}
616
617impl<B: Borrow<BitSet>> FusedIterator for IdxIter<B> {}
618
619#[cfg(test)]
620mod tests {
621 use super::*;
622
623 use std::iter;
624
625 #[test]
626 fn with_capacity() {
627 for cap in 0..FRAME_SIZE * 2 {
628 let mut set = BitSet::with_capacity(cap);
629
630 let frames = set.capacity();
631 for i in 0..cap {
632 set.insert(i);
633 assert_eq!(frames, set.capacity(), "{}/{}", i, cap);
634 }
635 }
636 }
637
638 #[test]
639 fn test() {
640 let mut set = BitSet::new();
641 assert_eq!(set, BitSet::default());
642 assert_eq!(set.element_count(), 0);
643 assert_eq!(set.get(1000000), false);
644 assert_eq!(set.inner.len(), 0);
645 assert!(set.is_empty());
646 set.insert(3);
647 assert_eq!(set.inner.len(), 1);
648 assert_eq!(set.get(3), true);
649 assert_eq!(set.get(4), false);
650 set.insert(5);
651 assert_eq!(set.element_count(), 2);
652 assert!(!set.is_empty());
653 assert_eq!(set.get(5), true);
654 set.insert(FRAME_SIZE + 2);
655 assert_eq!(set.inner.len(), 2);
656 assert_eq!(set.get(FRAME_SIZE + 2), true);
657 assert_eq!(set.get(FRAME_SIZE + 1), false);
658 set.flip(FRAME_SIZE + 4);
659 assert_eq!(set.get(FRAME_SIZE), false);
660 assert_eq!(set.get(FRAME_SIZE + 2), true);
661 assert_eq!(set.get(FRAME_SIZE + 4), true);
662 set.flip(FRAME_SIZE + 4);
663 assert_eq!(set.get(FRAME_SIZE + 4), false);
664 set.flip(FRAME_SIZE * 2 + 1);
665 assert_eq!(set.inner.len(), 3);
666 assert_eq!(set.get(FRAME_SIZE * 2 + 1), true);
667 assert_eq!(set.get(FRAME_SIZE * 2 + 3), false);
668 set.remove(FRAME_SIZE * 2 + 1);
669 assert_eq!(set.get(FRAME_SIZE * 2 + 1), false);
670 set.remove(FRAME_SIZE * 2 + 1);
671 assert_eq!(set.get(FRAME_SIZE * 2 + 1), false);
672 set.remove(FRAME_SIZE * 100);
673 assert_eq!(set.inner.len(), 2);
674 assert_eq!(set.element_count(), 3);
675 }
676
677 #[test]
678 fn disjoint() {
679 let a: BitSet = [1, 3].iter().collect();
680 let b: BitSet = [2, 5].iter().collect();
681 assert!(a.is_disjoint(&b));
682 }
683
684 #[test]
685 fn eq() {
686 let mut a = BitSet::new();
687 let mut b = BitSet::new();
688 a.insert(FRAME_SIZE * 2);
689 assert_ne!(a, b);
690 b.insert(FRAME_SIZE * 2);
691 assert_eq!(a, b);
692 a.insert(FRAME_SIZE * 3);
693 assert_ne!(a, b);
694 a.remove(FRAME_SIZE * 3);
695 assert_eq!(a, b);
696 b.insert(FRAME_SIZE * 4);
697 assert_ne!(a, b);
698 b.remove(FRAME_SIZE * 4);
699 assert_eq!(a, b);
700 }
701
702 #[test]
703 fn iter() {
704 let mut set: BitSet = [7, 4, 3, 4, 1, 1000].iter().collect();
705 assert_eq!(set.get(1), true);
706 assert_eq!(set.get(2), false);
707 assert_eq!(set.get(4), true);
708 set.insert(0);
709 assert_eq!(set.get(0), true);
710 assert_eq!(set.get(7), true);
711 assert_eq!(set.get(99), false);
712 assert_eq!(set.get(1000), true);
713
714 let mut iter = set.iter();
715 assert_eq!(iter.next(), Some(0));
716 assert_eq!(iter.next(), Some(1));
717 assert_eq!(iter.next(), Some(3));
718 assert_eq!(iter.next(), Some(4));
719 assert_eq!(iter.next(), Some(7));
720 assert_eq!(iter.next(), Some(1000));
721 assert_eq!(iter.next(), None);
722
723 set.remove(0);
724 set.extend(iter::once(5).chain(iter::once(1)));
725 assert_eq!(set.get(1), true);
726 assert_eq!(set.get(2), false);
727 assert_eq!(set.get(5), true);
728
729 let mut iter = set.into_iter();
730 assert_eq!(iter.next(), Some(1));
731 assert_eq!(iter.next(), Some(3));
732 assert_eq!(iter.next(), Some(4));
733 assert_eq!(iter.next_back(), Some(1000));
734 assert_eq!(iter.next_back(), Some(7));
735 assert_eq!(iter.next(), Some(5));
736 assert_eq!(iter.next(), None);
737 assert_eq!(iter.next_back(), None);
738
739 let set: BitSet = [0, 1].iter().collect();
740 let mut iter = set.iter();
741 assert_eq!(iter.next_back(), Some(1));
742 assert_eq!(iter.next_back(), Some(0));
743 assert_eq!(iter.next_back(), None);
744 let mut iter = set.iter();
745 assert_eq!(iter.next_back(), Some(1));
746 assert_eq!(iter.next(), Some(0));
747 assert_eq!(iter.next_back(), None);
748 let mut iter = set.iter();
749 assert_eq!(iter.next(), Some(0));
750 assert_eq!(iter.next_back(), Some(1));
751 assert_eq!(iter.next(), None);
752 }
753
754 #[test]
755 fn debug() {
756 fn assert_debug(content: &str, set: &BitSet) {
757 assert_eq!(
758 format!("BitSet {{ inner: {} }}", content),
759 format!("{:?}", set)
760 );
761 }
762
763 let mut set = BitSet::new();
764 assert_debug("0", &set);
765
766 set.insert(1);
767 assert_debug("01", &set);
768
769 set.insert(64);
770 assert_debug(
771 "01000000000000000000000000000000000000000000000000000000000000001",
772 &set,
773 );
774 }
775}