use zstd_seekable::{parallel_compress, Seekable, SeekableCStream};

use zstd_seekable::{Seekable, SeekableCStream};
#[cfg(feature = "threadpool")]
use zstd_seekable::parallel_compress;

const data: &[u8; 731] = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut diam ante, sollicitudin a dolor et, volutpat elementum nulla. Etiam nec efficitur nibh, quis rutrum risus. Maecenas quis lorem malesuada, aliquet mi vel, viverra nunc. Donec et nulla sed velit sagittis varius. Suspendisse vestibulum, neque lobortis ornare vestibulum, orci turpis vulputate nisi, ut sodales neque purus eget magna. Nunc condimentum, diam eu consequat venenatis, est nisl semper lorem, et lobortis velit justo sed nulla. Nunc sit amet tempor nunc, vel posuere ipsum. Cras erat tortor, pulvinar ac pretium eu, auctor ac nibh. Duis iaculis porta magna, eu lobortis elit. Duis vitae massa eros. Nulla non magna accumsan, egestas quam sit amet, laoreet lectus.";

const DATA: &[u8; 731] = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut diam ante, sollicitudin a dolor et, volutpat elementum nulla. Etiam nec efficitur nibh, quis rutrum risus. Maecenas quis lorem malesuada, aliquet mi vel, viverra nunc. Donec et nulla sed velit sagittis varius. Suspendisse vestibulum, neque lobortis ornare vestibulum, orci turpis vulputate nisi, ut sodales neque purus eget magna. Nunc condimentum, diam eu consequat venenatis, est nisl semper lorem, et lobortis velit justo sed nulla. Nunc sit amet tempor nunc, vel posuere ipsum. Cras erat tortor, pulvinar ac pretium eu, auctor ac nibh. Duis iaculis porta magna, eu lobortis elit. Duis vitae massa eros. Nulla non magna accumsan, egestas quam sit amet, laoreet lectus.";

#[cfg(feature = "threadpool")]

    const chunk_size: usize = 200;
    parallel_compress::<&mut Vec<u8>, [u8; chunk_size]>(data, &mut output, 10, 4, chunk_size)

    const CHUNK_SIZE: usize = 200;
    parallel_compress::<&mut Vec<u8>, [u8; CHUNK_SIZE]>(DATA, &mut output, 10, 4, CHUNK_SIZE)

    let mut start_offset = 0;
    let end_offset = data.len();
    let mut i = 0;

    assert_eq!(&data[..], &decomp[..])

    assert_eq!(&DATA[..], &decomp[..])

#[cfg(feature = "threadpool")]

    const chunk_size: usize = 128;
    parallel_compress::<&mut Vec<u8>, [u8; chunk_size]>(data, &mut output, 10, 4, chunk_size)

    const CHUNK_SIZE: usize = 128;
    parallel_compress::<&mut Vec<u8>, [u8; CHUNK_SIZE]>(DATA, &mut output, 10, 4, CHUNK_SIZE)

    let end_offset = data.len();

    let end_offset = DATA.len();

                &mut decomp[i * dst_size..(i + 1) * dst_size],
                dst_size as u64,

                &mut decomp[i * dst_size..i * dst_size + dst_size],

    assert_eq!(&data[..], &decomp[..])

    assert_eq!(&DATA[..], &decomp[..])

#[cfg(feature = "threadpool")]

    const chunk_size: usize = 100;
    parallel_compress::<&mut Vec<u8>, [u8; chunk_size]>(data, &mut output, 10, 4, chunk_size)

    const CHUNK_SIZE: usize = 100;
    parallel_compress::<&mut Vec<u8>, [u8; CHUNK_SIZE]>(DATA, &mut output, 10, 4, CHUNK_SIZE)

    let end_offset = data.len();

    let end_offset = DATA.len();

            .decompress(&mut decomp[..], dst_size as u64, start_offset as u64)

            .decompress(&mut decomp[..dst_size], start_offset as u64)

        assert_eq!(&data[i * b_size..i * b_size + dst_size], &decomp[..r]);

        assert_eq!(&DATA[i * b_size..i * b_size + dst_size], &decomp[..r]);

    let mut output = vec![0; data.len()];

    let mut output = vec![0; DATA.len()];

    while input_pos < data.len() {

    while input_pos < DATA.len() {

            .compress(&mut output[output_pos..], &data[input_pos..])

            .compress(&mut output[output_pos..], &DATA[input_pos..])

    println!("data len = {:?}, pos = {:?}", data.len(), output_pos);

    println!("data len = {:?}, pos = {:?}", DATA.len(), output_pos);

    let mut s = { Seekable::init_buf(&mut output).unwrap() };

    let mut s = { Seekable::init_buf(&output).unwrap() };

    assert_eq!(&data[..], &decomp[..])

    assert_eq!(&DATA[..], &decomp[..])

#[macro_use]
extern crate thiserror;
extern crate twox_hash;

use thiserror::*;

#[derive(Error)]

#[derive(Debug, Error)]

    #[error("Could not open file {}", 0)]

    ZSTD(size_t),

    #[error(transparent)]
    ZSTD(#[from] ZSTDError),
    #[error(transparent)]

    #[error("Null pointer")]

    #[error("Frame index too large, expected at most {}, found {}", 0, 1)]

    #[error("Unknown error")]

    #[error("An I/O error occurred when reading/seeking")]

    InvalidConversion,

    #[error("Unsupported frame parameter. Expected at most {}, found {}", 0, 1)]

    #[error("Unknown frame descriptor {}", 0)]

    #[error("Corrupted block detected {}", 0)]

    #[error("Destination buffer too small. Expected at most {}, found {}", 0, 1)]

impl fmt::Debug for Error {

#[derive(Error)]
pub struct ZSTDError(size_t);
impl fmt::Display for ZSTDError {

        match *self {
            Error::CouldNotOpenFile(ref f) => write!(fmt, "Could not open file {}.", f),
            Error::ZSTD(r) => unsafe {
                let error = CStr::from_ptr(ZSTD_getErrorName(r));
                write!(fmt, "ZSTD({:?}).", error)
            },
            Error::Io(ref e) => e.fmt(fmt),
            Error::Null => write!(fmt, "Null pointer."),
            Error::FIndexTooLarge(a, b) => write!(
                fmt,
                "Frame index too large. Expected at most {}, found {}.",
                a, b
            ),
            Error::Generic => write!(fmt, "Error (generic)."),
            Error::SeekableIo => write!(fmt, "An I/O error occurred when reading/seeking."),
            Error::InvalidConversion => write!(fmt, "Invalid slice to convert from bytes to u32."),
            Error::FParamUnsupported(a, b) => write!(
                fmt,
                "Unsupported frame parameter. Expected at most {}, found {}.",
                a, b
            ),
            Error::PrefixUnknown(p) => write!(fmt, "Unknown frame descriptor {}", p),
            Error::Corruption(ref s) => write!(fmt, "Corrupted block detected {}.", s),
            Error::DSizeTooSmall(a, b) => write!(
                fmt,
                "Destination buffer is too small. Expected at least {}, found {}.",
                b, a
            ),

        unsafe {
            let error = CStr::from_ptr(ZSTD_getErrorName(self.0));
            write!(fmt, "{}", error.to_str().unwrap())

impl fmt::Display for Error {

impl fmt::Debug for ZSTDError {

        write!(fmt, "{:?}", self)

        write!(fmt, "{}", self)

                return Err(Error::ZSTD(result));

                return Err(Error::ZSTD(ZSTDError(result)));

                return Err(Error::ZSTD(result));

                return Err(Error::ZSTD(ZSTDError(result)));

                return Err(Error::ZSTD(result));

                return Err(Error::ZSTD(ZSTDError(result)));

                return Err(Error::ZSTD(_result));

                return Err(Error::ZSTD(ZSTDError(_result)));

    Error, ZSTD_DStream, ZSTD_reset_session_only, BLOCK_SIZE_MAX, MAGIC_SKIPPABLE_START,

    Error, ZSTDError, ZSTD_DStream, ZSTD_reset_session_only, BLOCK_SIZE_MAX, MAGIC_SKIPPABLE_START,

use std::io::Read;
use twox_hash::xxh3::Hash64;

use xxhash_rust::xxh64::Xxh64;

const SEEKABLE_NO_OUTPUT_PROGRESS_MAX: u32 = 16;

// const SEEKABLE_NO_OUTPUT_PROGRESS_MAX: u32 = 16;

    Ok(u32::from_ne_bytes(b))

    Ok(u32::from_le_bytes(b))

    in_buff: [u8; SEEKABLE_BUFF_SIZE],
    out_buff: [u8; SEEKABLE_BUFF_SIZE],
    xxh_state: Hash64,

    in_buff: Vec<u8>,
    out_buff: Vec<u8>,
    xxh_state: Xxh64,

        let dstream = unsafe { ZSTD_createDStream() };
        if dstream.is_null() {
            return Err(Error::Null);

        unsafe {
            let dstream = ZSTD_createDStream();
            if dstream.is_null() {
                Err(Error::Null)
            } else {
                Ok(Seekable {
                    dstream,
                    seek_table: SeekTable::new(),
                    src: source,
                    inner_buf_size: size,
                    decompressed_offset: 0,
                    cur_frame: 0,
                    in_buff: vec![0; SEEKABLE_BUFF_SIZE],
                    out_buff: vec![0; SEEKABLE_BUFF_SIZE],
                    xxh_state: Xxh64::new(0),
                })
            }

        Ok(Seekable {
            dstream,
            seek_table: SeekTable::new(),
            src: source,
            inner_buf_size: size,
            decompressed_offset: 0,
            cur_frame: 0,
            in_buff: [0; SEEKABLE_BUFF_SIZE],
            out_buff: [0; SEEKABLE_BUFF_SIZE],
            xxh_state: Hash64::with_seed(0),
        })

        assert!(self.in_buff.len() == SEEKABLE_BUFF_SIZE);

        let mut handle = (&mut self.src).take(SEEK_TABLE_FOOTER_SIZE as u64);
        handle.read(&mut self.in_buff)?;

        self.src.read_exact(&mut self.in_buff[..SEEK_TABLE_FOOTER_SIZE])?;

        handle = (&mut self.src).take(to_read as u64);
        handle.read(&mut self.in_buff)?;

        self.src.read_exact(&mut self.in_buff[..to_read])?;

        let mut pos = 0usize;

        let mut pos = 8;

                self.in_buff.copy_within(pos..pos + offset, 0); // offset..offset + to_read, pos);

                self.in_buff.copy_within(offset..offset + to_read, pos);
                handle = (&mut self.src).take(to_read as u64);
                handle.read(&mut self.in_buff[offset..offset + to_read])?;

                self.src.read_exact(&mut self.in_buff[offset..offset + to_read])?;

                Err(Error::ZSTD(dstream_init))

                Err(Error::ZSTD(ZSTDError(dstream_init)))

        let mut no_output_progress_c = 0u32;

                self.xxh_state.reset(0);

                self.xxh_state = Hash64::with_seed(0);

                        return Err(Error::ZSTD(r));

                        return Err(Error::ZSTD(ZSTDError(r)));

                        return Err(Error::ZSTD(to_read));

                        return Err(Error::ZSTD(ZSTDError(to_read)));

                };

                }

                        &slice_tmp[prev_out_pos..prev_out_pos + (out_tmp.pos - prev_out_pos)],

                        &slice_tmp[prev_out_pos..out_tmp.pos],

                if forward_progress == 0 {
                    no_output_progress_c += 1;
                    if no_output_progress_c > SEEKABLE_NO_OUTPUT_PROGRESS_MAX {
                        return Err(Error::SeekableIo);
                    }
                } else {
                    no_output_progress_c = 0;
                }

                    // frame complete
                    // verify checksum
                    let f = self.xxh_state.finish();
                    let f = f as u32;

                        && self.xxh_state.finish() as u32

                        && f

                    let mut handle = (&mut self.src).take(to_read as u64);
                    handle.read(&mut self.in_buff)?;

                    self.in_buff.resize(to_read, 0u8);
                    self.src.read_exact(&mut self.in_buff)?;

    fn get_frame(&'_ self, frame_index: usize) -> Result<&'_ SeekEntry, Error> {

    fn get_frame(&self, frame_index: usize) -> Result<&'_ SeekEntry, Error> {

impl<'a> Seekable<std::io::Cursor<&'a mut [u8]>> {

impl<'a> Seekable<std::io::Cursor<&'a [u8]>> {

    pub fn init_buf(input: &'a mut [u8]) -> Result<Self, Error> {

    pub fn init_buf(input: &'a [u8]) -> Result<Self, Error> {

        let mut seekable = Seekable::make_seekable(source, Some(size))?;

        let mut seekable = if let Ok(s) = Seekable::make_seekable(source, Some(size)) {
            s
        } else {
            panic!("")
        };

#[test]
fn pijul_change() {
    let mut h = xxhash_rust::xxh64::Xxh64::new(0);
    h.update(&[4]);
    let d = 0x64b9da3ed69d6732;
    let f = h.finish();
    assert_eq!(d, f);
    let change = include_bytes!("../../.pijul/changes/IH/334Q5ACWE4TNQYYOOF6GWV6CRXOEM6542NVNPA6HRIZ3CBFKEAC.change");
    use serde_derive::*;
    #[derive(Deserialize)]
    pub struct Offsets {
        pub version: u64,
        pub hashed_len: u64,
        pub unhashed_off: u64,
        pub unhashed_len: u64,
        pub contents_off: u64,
        pub contents_len: u64,
        pub total: u64,
    }
    let off0 = std::mem::size_of::<Offsets>();
    let offsets: Offsets = bincode::deserialize(&change[..off0]).unwrap();
    let mut s = Seekable::init_buf(
        &change[off0..offsets.unhashed_off as usize],
    ).unwrap();
    let mut buf_ = Vec::new();
    buf_.resize(offsets.hashed_len as usize, 0);
    s.decompress(&mut buf_[..], 0).unwrap();
}

use super::{CStream, Error, ZSTD_reset_session_only};

use super::{CStream, Error, ZSTD_reset_session_only, ZSTDError};

use twox_hash::xxh3::{hash64, Hash64};

use xxhash_rust::xxh64::Xxh64;
// use twox_hash::xxh3::Hash64;

    xxh_state: Hash64,

    xxh_state: Xxh64,

                    return Err(Error::ZSTD(result));

                    return Err(Error::ZSTD(ZSTDError(result)));

                xxh_state: Hash64::with_seed(0),

                xxh_state: Xxh64::new(0),

                return Err(Error::ZSTD(r));

                return Err(Error::ZSTD(ZSTDError(r)));

            self.xxh_state = Hash64::with_seed(0);

            self.xxh_state = Xxh64::new(0);

                return Err(Error::ZSTD(ret));

                return Err(Error::ZSTD(ZSTDError(ret)));

                return Err(Error::ZSTD(ret));

                return Err(Error::ZSTD(ZSTDError(ret)));

                return Err(Error::ZSTD(end_frame));

                return Err(Error::ZSTD(ZSTDError(end_frame)));

            return Err(Error::ZSTD(result));

            return Err(Error::ZSTD(ZSTDError(result)));

}
pub trait Dst: Send {
    fn as_mut_ptr(&mut self) -> *mut u8;
    fn as_slice(&self) -> &[u8];
    fn len(&self) -> usize;
    fn new() -> Self;

impl<const N: usize> Dst for [u8; N] {
    fn as_mut_ptr(&mut self) -> *mut u8 {
        self.as_mut().as_mut_ptr()
    }
    fn as_slice(&self) -> &[u8] {
        self.as_ref()
    }
    fn len(&self) -> usize {
        N

#[cfg(feature = "threadpool")]
mod parallel_compress {
    use super::*;
    use xxhash_rust::xxh64::xxh64;
    pub trait Dst: Send {
        fn as_mut_ptr(&mut self) -> *mut u8;
        fn as_slice(&self) -> &[u8];
        fn len(&self) -> usize;
        fn new() -> Self;

    fn new() -> Self {
        unsafe { std::mem::MaybeUninit::uninit().assume_init() }

    impl<const N: usize> Dst for [u8; N] {
        fn as_mut_ptr(&mut self) -> *mut u8 {
            self.as_mut().as_mut_ptr()
        }
        fn as_slice(&self) -> &[u8] {
            self.as_ref()
        }
        fn len(&self) -> usize {
            N
        }
        fn new() -> Self {
            unsafe { std::mem::MaybeUninit::uninit().assume_init() }
        }

}

struct CompressedFrame<D: Dst> {
    src_size: u32,
    dst_size: u32,
    checksum: u32,
    dst: D,
}

    struct CompressedFrame<D: Dst> {
        src_size: u32,
        dst_size: u32,
        checksum: u32,
        dst: D,
    }

impl<D: Dst> CompressedFrame<D> {
    fn as_slice(&self) -> &[u8] {
        &self.dst.as_slice()[..self.dst_size as usize]

    impl<D: Dst> CompressedFrame<D> {
        fn as_slice(&self) -> &[u8] {
            &self.dst.as_slice()[..self.dst_size as usize]
        }

}

unsafe impl<D: Dst> Send for CompressedFrame<D> {}

    unsafe impl<D: Dst> Send for CompressedFrame<D> {}

fn compress_frame<D: Dst>(src: &[u8], level: usize) -> Result<CompressedFrame<D>, Error> {
    let mut dst = D::new();

    fn compress_frame<D: Dst>(src: &[u8], level: usize) -> Result<CompressedFrame<D>, Error> {
        let mut dst = D::new();

    let ret = unsafe {
        let ret = ZSTD_compress(
            dst.as_mut_ptr() as *mut c_void,
            dst.len() as size_t,
            src.as_ptr() as *const c_void,
            src.len() as size_t,
            level as c_int,
        );

        let ret = unsafe {
            let ret = ZSTD_compress(
                dst.as_mut_ptr() as *mut c_void,
                dst.len() as size_t,
                src.as_ptr() as *const c_void,
                src.len() as size_t,
                level as c_int,
            );

        if ZSTD_isError(ret) != 0 {
            return Err(Error::ZSTD(ret));
        }

            if ZSTD_isError(ret) != 0 {
                return Err(Error::ZSTD(ZSTDError(ret)));
            }

        ret
    };

            ret
        };

    let checksum = hash64(src) as u32;

        let checksum = xxh64(src, 0) as u32;

    Ok(CompressedFrame {
        src_size: src.len() as u32,
        dst_size: ret as u32,
        checksum,
        dst,
    })
}

        Ok(CompressedFrame {
            src_size: src.len() as u32,
            dst_size: ret as u32,
            checksum,
            dst,
        })
    }

pub fn parallel_compress<W: std::io::Write, D: Dst + 'static>(
    src: &'static [u8],
    mut output: W,
    level: usize,
    jobs: usize,
    chunk_size: usize,
) -> Result<(), Error> {
    use std::sync::mpsc::channel;
    use threadpool::ThreadPool;

    pub fn parallel_compress<W: std::io::Write, D: Dst + 'static>(
        src: &'static [u8],
        mut output: W,
        level: usize,
        jobs: usize,
        chunk_size: usize,
    ) -> Result<(), Error> {
        use std::sync::mpsc::channel;
        use threadpool::ThreadPool;

    let n = src.len() / chunk_size + if src.len() % chunk_size == 0 { 0 } else { 1 };
    let pool = ThreadPool::new(jobs);

        let n = src.len() / chunk_size + if src.len() % chunk_size == 0 { 0 } else { 1 };
        let pool = ThreadPool::new(jobs);

    let (tx, rx) = channel();
    for (i, chunk) in src.chunks(chunk_size).enumerate() {
        let tx = tx.clone();
        pool.execute(move || {
            let frame = compress_frame(chunk, level);
            tx.send((i, frame))
                .expect("channel will be there waiting for the pool");
        });
    }

        let (tx, rx) = channel();
        for (i, chunk) in src.chunks(chunk_size).enumerate() {
            let tx = tx.clone();
            pool.execute(move || {
                let frame = compress_frame(chunk, level);
                tx.send((i, frame))
                    .expect("channel will be there waiting for the pool");
            });
        }

    let mut frames: Vec<CompressedFrame<D>> = Vec::with_capacity(n);
    unsafe { frames.set_len(n) };
    for (i, frame) in rx.iter().take(n) {
        frames[i] = frame?;
    }

        let mut frames: Vec<CompressedFrame<D>> = Vec::with_capacity(n);
        unsafe { frames.set_len(n) };
        for (i, frame) in rx.iter().take(n) {
            frames[i] = frame?;
        }

    let mut log = FrameLog::new();
    for frame in frames.iter() {
        output.write_all(frame.as_slice())?;
        log.log_frame(frame.dst_size, frame.src_size, frame.checksum)?;

        let mut log = FrameLog::new();
        for frame in frames.iter() {
            output.write_all(frame.as_slice())?;
            log.log_frame(frame.dst_size, frame.src_size, frame.checksum)?;
        }
        log.write_all(&mut output)?;
        Ok(())

    log.write_all(&mut output)?;
    Ok(())

#[cfg(feature = "threadpool")]
pub use parallel_compress::*;

    Error, ZSTD_outBuffer,

    Error,

use libc::*;

// use libc::*;

    #[cfg(feature = "threadpool")]

    #[cfg(feature = "threadpool")]

        use crate::ZSTD_outBuffer;
        use libc::c_void;

    #[cfg(feature = "threadpool")]

threadpool = "1.8"
twox-hash = "1.6.0"

threadpool = { version = "1.8", optional = true }
xxhash-rust = { version = "0.8.2", features = [ "xxh64" ] }

pkg-config = "0.3"

pkg-config = "0.3"
[dev-dependencies]
bincode = "1.0"
serde = "1.0"
serde_derive = "1.0"

[[package]]
name = "cfg-if"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"

version = 3

name = "cfg-if"
version = "1.0.0"

name = "bincode"
version = "1.3.3"

checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
[[package]]
name = "getrandom"
version = "0.1.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"

checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"

 "cfg-if 1.0.0",
 "libc",
 "wasi",

 "serde",

name = "ppv-lite86"
version = "0.2.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857"
[[package]]

version = "1.0.27"

version = "1.0.29"

checksum = "f0d8caf72986c1a598726adc988bb5984792ef84f5ee5aa50209145ee8077038"

checksum = "b9f5105d4fdaab20335ca9565e106a5d9b82b6219b5ba735731124ac6711d23d"

]
[[package]]
name = "rand"
version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
dependencies = [
 "getrandom",
 "libc",
 "rand_chacha",
 "rand_core",
 "rand_hc",
]
[[package]]
name = "rand_chacha"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
dependencies = [
 "ppv-lite86",
 "rand_core",

name = "rand_core"
version = "0.5.1"

name = "serde"
version = "1.0.130"

checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
dependencies = [
 "getrandom",
]

checksum = "f12d06de37cf59146fbdecab66aa99f9fe4f78722e3607577a5375d66bd0c913"

name = "rand_hc"
version = "0.2.0"

name = "serde_derive"
version = "1.0.130"

checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"

checksum = "d7bc1a1ab1961464eae040d96713baa5a724a8152c1222492465b54322ec508b"

 "rand_core",

 "proc-macro2",
 "quote",
 "syn",

[[package]]
name = "static_assertions"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"

version = "1.0.73"

version = "1.0.76"

checksum = "f71489ff30030d2ae598524f61326b902466f72a0fb1a8564c001cc63425bcc7"

checksum = "c6f107db402c2c2055242dbf4d2af0e69197202e9faacbef9571bbe47f5a1b84"

version = "1.0.26"

version = "1.0.29"

checksum = "93119e4feac1cbe6c798c34d3a53ea0026b0b1de6a120deef895137c0529bfe2"

checksum = "602eca064b2d83369e2b2f34b09c70b605402801927c65c11071ac911d299b88"

version = "1.0.26"

version = "1.0.29"

checksum = "060d69a0afe7796bf42e9e2ff91f5ee691fb15c53d38b4b62a9a53eb23164745"

checksum = "bad553cc2c78e8de258400763a647e80e6d1b31ee237275d756f6836d204494c"

]
[[package]]
name = "twox-hash"
version = "1.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "04f8ab788026715fa63b31960869617cba39117e520eb415b0139543e325ab59"
dependencies = [
 "cfg-if 0.1.10",
 "rand",
 "static_assertions",

name = "wasi"
version = "0.9.0+wasi-snapshot-preview1"

name = "xxhash-rust"
version = "0.8.2"

checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"

checksum = "e575e15bedf6e57b5c2d763ffc6c3c760143466cbd09d762d539680ab5992ded"

 "bincode",

 "serde",
 "serde_derive",

 "twox-hash",

 "xxhash-rust",