let n = 10_000_000u64;

    let n = 1_000u64;

    add_free_refs_mut(&mut txn, &mut refs).unwrap();

    let mut db = create_db_::<MutTxn<&Env, ()>, u64, u64, UP<u64, u64>>(&mut txn).unwrap();

    let env = Env::new_anon(409_600_000, 1).unwrap();
    let mut txn = Env::mut_txn_begin(&env).unwrap();
    let mut db2 = create_db_::<MutTxn<&Env, ()>, u64, u64, UP<u64, u64>>(&mut txn).unwrap();

    let n = 1_000u64;

        debug!("=================== {:?}", i);
        assert!(put(&mut txn, &mut db, &i, &i).unwrap());

        assert!(put(&mut txn, &mut db2, &i, &i).unwrap());

        debug!("=================== {:?}", i);
        get(&txn, &db, &i, None).unwrap();

        get(&txn, &db2, &i, None).unwrap();

    println!("unsized length = {:?}", (txn.length >> 12) - len);
    add_refs(&txn, &db, &mut refs).unwrap();
    for (p, r) in refs.iter() {
        if *r >= 2 {
            error!("{:?} referenced twice", p);
            err += 1
        }
    }
    assert_eq!(err, 0);

    refs.clear();
    add_refs(&txn, &db2, &mut refs).unwrap();
    add_free_refs_mut(&mut txn, &mut refs).unwrap();

//!
//! Here's an example of how to use it (starting with 64 pages, 2
//! versions, see below for details about what that means). The file
//! grows automatically, as needed.
//!
//! ```
//! use sanakirja::*;
//! let dir = tempfile::tempdir().unwrap();
//! let path = dir.path().join("db");
//! let env = Env::new(&path, 1 << 20, 2).unwrap();
//! let mut txn = Env::mut_txn_begin(&env).unwrap();
//! let mut db = btree::create_db::<_, u64, u64>(&mut txn).unwrap();
//! for i in 0..100_000u64 {
//!     btree::put(&mut txn, &mut db, &i, &(i*i)).unwrap();
//! }
//! let root_db = 0;
//! txn.set_root(root_db, db.db);
//! txn.commit().unwrap();
//! let txn = Env::txn_begin(&env).unwrap();
//! let db: btree::Db<u64, u64> = txn.root_db(root_db).unwrap();
//! assert_eq!(btree::get(&txn, &db, &50_000, None).unwrap(), Some((&50_000, &(50_000 * 50_000))));
//! for entry in btree::iter(&txn, &db, None).unwrap() {
//!   let (k, v) = entry.unwrap();
//!   assert_eq!(*k * *k, *v)
//! }
//! ```

    rc: Option<btree::Db<u64, ()>>,

    pub(crate) rc: Option<btree::Db<u64, ()>>,

        } else if txn.free_owned_pages.iter().any(|x| *x == page) {
            continue;
        } else if txn.free_pages.iter().any(|x| *x == page) {
            continue;

    let env = txn.env.borrow();
    unsafe {
        let p = &*(env.mmaps.lock()[0].ptr.add(txn.root * PAGE_SIZE)
            as *const crate::environment::GlobalHeader);
        if p.free_db != 0 {
            debug!("add_free_refs: free = 0x{:x}", p.free_db);
            let free_db: Db<u64, ()> = btree::Db::from_page(p.free_db);
            add_refs(txn, &free_db, pages)?;
        }
        if p.rc_db != 0 {
            debug!("add_free_refs: rc = 0x{:x}", p.rc_db);
            let rc_db: Db<u64, ()> = btree::Db::from_page(p.rc_db);
            add_refs(txn, &rc_db, pages)?;
        }
    };

    if txn.free != 0 {
        debug!("add_free_refs: free = 0x{:x}", txn.free);
        let free_db: Db<u64, ()> = btree::Db::from_page(txn.free);
        add_refs(txn, &free_db, pages)?;
    }
    if let Some(ref rc) = txn.rc {
        debug!("add_free_refs: rc = 0x{:x}", rc.db);
        add_refs(txn, &rc, pages)?;
    }

version = "1.0.0"

version = "1.0.1"