about summary refs log tree commit diff
path: root/src/libstd/bitv.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd/bitv.rs')
-rw-r--r--src/libstd/bitv.rs228
1 files changed, 114 insertions, 114 deletions
diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs
index 939f6960bf9..b54c50da35c 100644
--- a/src/libstd/bitv.rs
+++ b/src/libstd/bitv.rs
@@ -132,7 +132,7 @@ pub impl BigBitv {
     fn process(&mut self, b: &BigBitv, nbits: uint,
                op: fn(uint, uint) -> uint) -> bool {
         let len = b.storage.len();
-        assert (self.storage.len() == len);
+        fail_unless!((self.storage.len() == len));
         let mut changed = false;
         for uint::range(0, len) |i| {
             let mask = big_mask(nbits, i);
@@ -300,7 +300,7 @@ pub impl Bitv {
     /// Retrieve the value at index `i`
     #[inline(always)]
     pure fn get(&self, i: uint) -> bool {
-       assert (i < self.nbits);
+       fail_unless!((i < self.nbits));
        match self.rep {
          Big(ref b)   => b.get(i),
          Small(ref s) => s.get(i)
@@ -314,7 +314,7 @@ pub impl Bitv {
      */
     #[inline(always)]
     fn set(&mut self, i: uint, x: bool) {
-      assert (i < self.nbits);
+      fail_unless!((i < self.nbits));
       match self.rep {
         Big(ref mut b)   => b.set(i, x),
         Small(ref mut s) => s.set(i, x)
@@ -482,7 +482,7 @@ pub impl Bitv {
      * the bitvector and vector must have the same length
      */
     fn eq_vec(&self, v: ~[uint]) -> bool {
-        assert self.nbits == v.len();
+        fail_unless!(self.nbits == v.len());
         let mut i = 0;
         while i < self.nbits {
             let w0 = self.get(i);
@@ -723,7 +723,7 @@ impl Set<uint> for BitvSet {
         let nbits = self.capacity();
         if value >= nbits {
             let newsize = uint::max(value, nbits * 2) / uint::bits + 1;
-            assert newsize > self.bitv.storage.len();
+            fail_unless!(newsize > self.bitv.storage.len());
             self.bitv.storage.grow(newsize, &0);
         }
         self.size += 1;
@@ -882,10 +882,10 @@ mod tests {
     #[test]
     pub fn test_to_str() {
         let zerolen = Bitv::new(0u, false);
-        assert zerolen.to_str() == ~"";
+        fail_unless!(zerolen.to_str() == ~"");
 
         let eightbits = Bitv::new(8u, false);
-        assert eightbits.to_str() == ~"00000000";
+        fail_unless!(eightbits.to_str() == ~"00000000");
     }
 
     #[test]
@@ -894,16 +894,16 @@ mod tests {
         let mut exp;
         act = Bitv::new(0u, false);
         exp = vec::from_elem::<uint>(0u, 0u);
-        assert act.eq_vec(exp);
+        fail_unless!(act.eq_vec(exp));
     }
 
     #[test]
     pub fn test_1_element() {
         let mut act;
         act = Bitv::new(1u, false);
-        assert act.eq_vec(~[0u]);
+        fail_unless!(act.eq_vec(~[0u]));
         act = Bitv::new(1u, true);
-        assert act.eq_vec(~[1u]);
+        fail_unless!(act.eq_vec(~[1u]));
     }
 
     #[test]
@@ -911,7 +911,7 @@ mod tests {
         let mut b = bitv::Bitv::new(2, false);
         b.set(0, true);
         b.set(1, false);
-        assert b.to_str() == ~"10";
+        fail_unless!(b.to_str() == ~"10");
     }
 
     #[test]
@@ -920,11 +920,11 @@ mod tests {
         // all 0
 
         act = Bitv::new(10u, false);
-        assert (act.eq_vec(~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u]));
+        fail_unless!((act.eq_vec(~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u])));
         // all 1
 
         act = Bitv::new(10u, true);
-        assert (act.eq_vec(~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u]));
+        fail_unless!((act.eq_vec(~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u])));
         // mixed
 
         act = Bitv::new(10u, false);
@@ -933,7 +933,7 @@ mod tests {
         act.set(2u, true);
         act.set(3u, true);
         act.set(4u, true);
-        assert (act.eq_vec(~[1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u]));
+        fail_unless!((act.eq_vec(~[1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u])));
         // mixed
 
         act = Bitv::new(10u, false);
@@ -942,7 +942,7 @@ mod tests {
         act.set(7u, true);
         act.set(8u, true);
         act.set(9u, true);
-        assert (act.eq_vec(~[0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u]));
+        fail_unless!((act.eq_vec(~[0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u])));
         // mixed
 
         act = Bitv::new(10u, false);
@@ -950,7 +950,7 @@ mod tests {
         act.set(3u, true);
         act.set(6u, true);
         act.set(9u, true);
-        assert (act.eq_vec(~[1u, 0u, 0u, 1u, 0u, 0u, 1u, 0u, 0u, 1u]));
+        fail_unless!((act.eq_vec(~[1u, 0u, 0u, 1u, 0u, 0u, 1u, 0u, 0u, 1u])));
     }
 
     #[test]
@@ -959,14 +959,14 @@ mod tests {
         // all 0
 
         act = Bitv::new(31u, false);
-        assert (act.eq_vec(
+        fail_unless!(act.eq_vec(
                        ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u]));
         // all 1
 
         act = Bitv::new(31u, true);
-        assert (act.eq_vec(
+        fail_unless!(act.eq_vec(
                        ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                         1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                         1u, 1u, 1u, 1u, 1u]));
@@ -981,7 +981,7 @@ mod tests {
         act.set(5u, true);
         act.set(6u, true);
         act.set(7u, true);
-        assert (act.eq_vec(
+        fail_unless!(act.eq_vec(
                        ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u]));
@@ -996,7 +996,7 @@ mod tests {
         act.set(21u, true);
         act.set(22u, true);
         act.set(23u, true);
-        assert (act.eq_vec(
+        fail_unless!(act.eq_vec(
                        ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u]));
@@ -1010,7 +1010,7 @@ mod tests {
         act.set(28u, true);
         act.set(29u, true);
         act.set(30u, true);
-        assert (act.eq_vec(
+        fail_unless!(act.eq_vec(
                        ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u,
                         1u, 1u, 1u, 1u, 1u]));
@@ -1020,7 +1020,7 @@ mod tests {
         act.set(3u, true);
         act.set(17u, true);
         act.set(30u, true);
-        assert (act.eq_vec(
+        fail_unless!(act.eq_vec(
                        ~[0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 1u]));
@@ -1032,14 +1032,14 @@ mod tests {
         // all 0
 
         act = Bitv::new(32u, false);
-        assert (act.eq_vec(
+        fail_unless!(act.eq_vec(
                        ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u]));
         // all 1
 
         act = Bitv::new(32u, true);
-        assert (act.eq_vec(
+        fail_unless!(act.eq_vec(
                        ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                         1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                         1u, 1u, 1u, 1u, 1u, 1u]));
@@ -1054,7 +1054,7 @@ mod tests {
         act.set(5u, true);
         act.set(6u, true);
         act.set(7u, true);
-        assert (act.eq_vec(
+        fail_unless!(act.eq_vec(
                        ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u]));
@@ -1069,7 +1069,7 @@ mod tests {
         act.set(21u, true);
         act.set(22u, true);
         act.set(23u, true);
-        assert (act.eq_vec(
+        fail_unless!(act.eq_vec(
                        ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u]));
@@ -1084,7 +1084,7 @@ mod tests {
         act.set(29u, true);
         act.set(30u, true);
         act.set(31u, true);
-        assert (act.eq_vec(
+        fail_unless!(act.eq_vec(
                        ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u,
                         1u, 1u, 1u, 1u, 1u, 1u]));
@@ -1095,7 +1095,7 @@ mod tests {
         act.set(17u, true);
         act.set(30u, true);
         act.set(31u, true);
-        assert (act.eq_vec(
+        fail_unless!(act.eq_vec(
                        ~[0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 1u, 1u]));
@@ -1107,14 +1107,14 @@ mod tests {
         // all 0
 
         act = Bitv::new(33u, false);
-        assert (act.eq_vec(
+        fail_unless!(act.eq_vec(
                        ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u]));
         // all 1
 
         act = Bitv::new(33u, true);
-        assert (act.eq_vec(
+        fail_unless!(act.eq_vec(
                        ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                         1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                         1u, 1u, 1u, 1u, 1u, 1u, 1u]));
@@ -1129,7 +1129,7 @@ mod tests {
         act.set(5u, true);
         act.set(6u, true);
         act.set(7u, true);
-        assert (act.eq_vec(
+        fail_unless!(act.eq_vec(
                        ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u]));
@@ -1144,7 +1144,7 @@ mod tests {
         act.set(21u, true);
         act.set(22u, true);
         act.set(23u, true);
-        assert (act.eq_vec(
+        fail_unless!(act.eq_vec(
                        ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u]));
@@ -1159,7 +1159,7 @@ mod tests {
         act.set(29u, true);
         act.set(30u, true);
         act.set(31u, true);
-        assert (act.eq_vec(
+        fail_unless!(act.eq_vec(
                        ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u,
                         1u, 1u, 1u, 1u, 1u, 1u, 0u]));
@@ -1171,7 +1171,7 @@ mod tests {
         act.set(30u, true);
         act.set(31u, true);
         act.set(32u, true);
-        assert (act.eq_vec(
+        fail_unless!(act.eq_vec(
                        ~[0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 1u, 1u, 1u]));
@@ -1181,14 +1181,14 @@ mod tests {
     pub fn test_equal_differing_sizes() {
         let v0 = Bitv::new(10u, false);
         let v1 = Bitv::new(11u, false);
-        assert !v0.equal(&v1);
+        fail_unless!(!v0.equal(&v1));
     }
 
     #[test]
     pub fn test_equal_greatly_differing_sizes() {
         let v0 = Bitv::new(10u, false);
         let v1 = Bitv::new(110u, false);
-        assert !v0.equal(&v1);
+        fail_unless!(!v0.equal(&v1));
     }
 
     #[test]
@@ -1199,7 +1199,7 @@ mod tests {
         let mut b = bitv::Bitv::new(1, true);
         b.set(0, true);
 
-        assert a.equal(&b);
+        fail_unless!(a.equal(&b));
     }
 
     #[test]
@@ -1214,37 +1214,37 @@ mod tests {
             b.set(i, true);
         }
 
-        assert a.equal(&b);
+        fail_unless!(a.equal(&b));
     }
 
     #[test]
     pub fn test_from_bytes() {
         let bitv = from_bytes([0b10110110, 0b00000000, 0b11111111]);
         let str = ~"10110110" + ~"00000000" + ~"11111111";
-        assert bitv.to_str() == str;
+        fail_unless!(bitv.to_str() == str);
     }
 
     #[test]
     pub fn test_to_bytes() {
         let mut bv = Bitv::new(3, true);
         bv.set(1, false);
-        assert bv.to_bytes() == ~[0b10100000];
+        fail_unless!(bv.to_bytes() == ~[0b10100000]);
 
         let mut bv = Bitv::new(9, false);
         bv.set(2, true);
         bv.set(8, true);
-        assert bv.to_bytes() == ~[0b00100000, 0b10000000];
+        fail_unless!(bv.to_bytes() == ~[0b00100000, 0b10000000]);
     }
 
     #[test]
     pub fn test_from_bools() {
-        assert from_bools([true, false, true, true]).to_str() == ~"1011";
+        fail_unless!(from_bools([true, false, true, true]).to_str() == ~"1011");
     }
 
     #[test]
     pub fn test_to_bools() {
         let bools = ~[false, false, true, false, false, true, true, false];
-        assert from_bytes([0b00100110]).to_bools() == bools;
+        fail_unless!(from_bytes([0b00100110]).to_bools() == bools);
     }
 
     #[test]
@@ -1255,10 +1255,10 @@ mod tests {
         b1.set(1, true);
         b2.set(1, true);
         b2.set(2, true);
-        assert b1.difference(&b2);
-        assert b1[0];
-        assert !b1[1];
-        assert !b1[2];
+        fail_unless!(b1.difference(&b2));
+        fail_unless!(b1[0]);
+        fail_unless!(!b1[1]);
+        fail_unless!(!b1[2]);
     }
 
     #[test]
@@ -1269,10 +1269,10 @@ mod tests {
         b1.set(40, true);
         b2.set(40, true);
         b2.set(80, true);
-        assert b1.difference(&b2);
-        assert b1[0];
-        assert !b1[40];
-        assert !b1[80];
+        fail_unless!(b1.difference(&b2));
+        fail_unless!(b1[0]);
+        fail_unless!(!b1[40]);
+        fail_unless!(!b1[80]);
     }
 
     #[test]
@@ -1296,13 +1296,13 @@ mod tests {
     #[test]
     pub fn test_bitv_set_basic() {
         let mut b = BitvSet::new();
-        assert b.insert(3);
-        assert !b.insert(3);
-        assert b.contains(&3);
-        assert b.insert(400);
-        assert !b.insert(400);
-        assert b.contains(&400);
-        assert b.len() == 2;
+        fail_unless!(b.insert(3));
+        fail_unless!(!b.insert(3));
+        fail_unless!(b.contains(&3));
+        fail_unless!(b.insert(400));
+        fail_unless!(!b.insert(400));
+        fail_unless!(b.contains(&400));
+        fail_unless!(b.len() == 2);
     }
 
     #[test]
@@ -1310,26 +1310,26 @@ mod tests {
         let mut a = BitvSet::new();
         let mut b = BitvSet::new();
 
-        assert a.insert(11);
-        assert a.insert(1);
-        assert a.insert(3);
-        assert a.insert(77);
-        assert a.insert(103);
-        assert a.insert(5);
+        fail_unless!(a.insert(11));
+        fail_unless!(a.insert(1));
+        fail_unless!(a.insert(3));
+        fail_unless!(a.insert(77));
+        fail_unless!(a.insert(103));
+        fail_unless!(a.insert(5));
 
-        assert b.insert(2);
-        assert b.insert(11);
-        assert b.insert(77);
-        assert b.insert(5);
-        assert b.insert(3);
+        fail_unless!(b.insert(2));
+        fail_unless!(b.insert(11));
+        fail_unless!(b.insert(77));
+        fail_unless!(b.insert(5));
+        fail_unless!(b.insert(3));
 
         let mut i = 0;
         let expected = [3, 5, 11, 77];
         for a.intersection(&b) |x| {
-            assert *x == expected[i];
+            fail_unless!(*x == expected[i]);
             i += 1
         }
-        assert i == expected.len();
+        fail_unless!(i == expected.len());
     }
 
     #[test]
@@ -1337,22 +1337,22 @@ mod tests {
         let mut a = BitvSet::new();
         let mut b = BitvSet::new();
 
-        assert a.insert(1);
-        assert a.insert(3);
-        assert a.insert(5);
-        assert a.insert(200);
-        assert a.insert(500);
+        fail_unless!(a.insert(1));
+        fail_unless!(a.insert(3));
+        fail_unless!(a.insert(5));
+        fail_unless!(a.insert(200));
+        fail_unless!(a.insert(500));
 
-        assert b.insert(3);
-        assert b.insert(200);
+        fail_unless!(b.insert(3));
+        fail_unless!(b.insert(200));
 
         let mut i = 0;
         let expected = [1, 5, 500];
         for a.difference(&b) |x| {
-            assert *x == expected[i];
+            fail_unless!(*x == expected[i]);
             i += 1
         }
-        assert i == expected.len();
+        fail_unless!(i == expected.len());
     }
 
     #[test]
@@ -1360,67 +1360,67 @@ mod tests {
         let mut a = BitvSet::new();
         let mut b = BitvSet::new();
 
-        assert a.insert(1);
-        assert a.insert(3);
-        assert a.insert(5);
-        assert a.insert(9);
-        assert a.insert(11);
+        fail_unless!(a.insert(1));
+        fail_unless!(a.insert(3));
+        fail_unless!(a.insert(5));
+        fail_unless!(a.insert(9));
+        fail_unless!(a.insert(11));
 
-        assert b.insert(3);
-        assert b.insert(9);
-        assert b.insert(14);
-        assert b.insert(220);
+        fail_unless!(b.insert(3));
+        fail_unless!(b.insert(9));
+        fail_unless!(b.insert(14));
+        fail_unless!(b.insert(220));
 
         let mut i = 0;
         let expected = [1, 5, 11, 14, 220];
         for a.symmetric_difference(&b) |x| {
-            assert *x == expected[i];
+            fail_unless!(*x == expected[i]);
             i += 1
         }
-        assert i == expected.len();
+        fail_unless!(i == expected.len());
     }
 
     #[test]
     pub fn test_bitv_set_union() {
         let mut a = BitvSet::new();
         let mut b = BitvSet::new();
-        assert a.insert(1);
-        assert a.insert(3);
-        assert a.insert(5);
-        assert a.insert(9);
-        assert a.insert(11);
-        assert a.insert(160);
-        assert a.insert(19);
-        assert a.insert(24);
-
-        assert b.insert(1);
-        assert b.insert(5);
-        assert b.insert(9);
-        assert b.insert(13);
-        assert b.insert(19);
+        fail_unless!(a.insert(1));
+        fail_unless!(a.insert(3));
+        fail_unless!(a.insert(5));
+        fail_unless!(a.insert(9));
+        fail_unless!(a.insert(11));
+        fail_unless!(a.insert(160));
+        fail_unless!(a.insert(19));
+        fail_unless!(a.insert(24));
+
+        fail_unless!(b.insert(1));
+        fail_unless!(b.insert(5));
+        fail_unless!(b.insert(9));
+        fail_unless!(b.insert(13));
+        fail_unless!(b.insert(19));
 
         let mut i = 0;
         let expected = [1, 3, 5, 9, 11, 13, 19, 24, 160];
         for a.union(&b) |x| {
-            assert *x == expected[i];
+            fail_unless!(*x == expected[i]);
             i += 1
         }
-        assert i == expected.len();
+        fail_unless!(i == expected.len());
     }
 
     #[test]
     pub fn test_bitv_remove() {
         let mut a = BitvSet::new();
 
-        assert a.insert(1);
-        assert a.remove(&1);
+        fail_unless!(a.insert(1));
+        fail_unless!(a.remove(&1));
 
-        assert a.insert(100);
-        assert a.remove(&100);
+        fail_unless!(a.insert(100));
+        fail_unless!(a.remove(&100));
 
-        assert a.insert(1000);
-        assert a.remove(&1000);
-        assert a.capacity() == uint::bits;
+        fail_unless!(a.insert(1000));
+        fail_unless!(a.remove(&1000));
+        fail_unless!(a.capacity() == uint::bits);
     }
 
     fn rng() -> rand::Rng {
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2025-10-27 08:37:34 +0000