pub fn pop_last_in_range<K, R>(
        &self,
        range: R,
    ) -> io::Result<Option<(InlineArray, InlineArray)>>
    where
        K: AsRef<[u8]>,
        R: Clone + RangeBounds<K>,
    {
        loop {
            let mut r = self.range(range.clone());
            let (k, v) = if let Some(kv_res) = r.next_back() {
                kv_res?
            } else {
                return Ok(None);
            };
            if self
                .compare_and_swap(&k, Some(&v), None as Option<InlineArray>)?
                .is_ok()
            {
                return Ok(Some((k, v)));
            }
        }
    }
Pops the last kv pair in the provided range, or returns `Ok(None)` if nothing
exists within that range.

# Panics

This will panic if the provided range's end_bound() == Bound::Excluded(K::MIN).

# Examples

```
# fn main() -> Result<(), Box<dyn std::error::Error>> {
# let config = sled::Config::tmp().unwrap();
# let db: sled::Db<1024> = config.open()?;

let data = vec![
(b"key 1", b"value 1"),
(b"key 2", b"value 2"),
(b"key 3", b"value 3")
];

for (k, v) in data {
db.insert(k, v).unwrap();
}

let r1 = db.pop_last_in_range(b"key 1".as_ref()..=b"key 3").unwrap();
assert_eq!(Some((b"key 3".into(), b"value 3".into())), r1);

let r2 = db.pop_last_in_range(b"key 1".as_ref()..b"key 3").unwrap();
assert_eq!(Some((b"key 2".into(), b"value 2".into())), r2);

let r3 = db.pop_last_in_range(b"key 4".as_ref()..).unwrap();
assert!(r3.is_none());

let r4 = db.pop_last_in_range(b"key 2".as_ref()..=b"key 3").unwrap();
assert!(r4.is_none());

let r5 = db.pop_last_in_range(b"key 0".as_ref()..=b"key 3").unwrap();
assert_eq!(Some((b"key 1".into(), b"value 1".into())), r5);

let r6 = db.pop_last_in_range(b"key 0".as_ref()..=b"key 3").unwrap();
assert!(r6.is_none());
# Ok (()) }
```
src/tree.rs