o01eg/sendxmppd-rs - Change OB3HA2MD7TDBGGURKXNQKLLLC5FAAD5OX5BENF3M2XNU7OTJ5HHAC

Use Client::new_with_jid to parse jid only once

Created by O01eg on January 21, 2019

OB3HA2MD7TDBGGURKXNQKLLLC5FAAD5OX5BENF3M2XNU7OTJ5HHAC

Dependencies

In channels

main

Change contents

Insertion in src/xmpp/stanzas.rs at line 2 [3.13]

[3.57]

use xmpp_parsers::iq::Iq;
use xmpp_parsers::message::{Body, Message, MessageType};

Insertion in src/xmpp/stanzas.rs at line 5 [3.13]
[3.141]
[3.141]
```
use xmpp_parsers::roster::{Item, Roster};
```

Insertion in src/xmpp/stanzas.rs at line 13 [3.13]

[3.397]

[4.207]

    presence.into()
}
pub fn make_get_roster(id: &str) -> Element {
    let mut get_roster = Iq::from_get(Roster {
        items: vec![],
        ver: None,
    });
    get_roster.id = Some(id.to_string());
    get_roster.into()
}
pub fn make_add_roster(id: &str, jid: xmpp_parsers::Jid) -> Element {
    let mut add_roster = Iq::from_set(Roster {
        items: vec![Item {
            jid,
            name: None,
            subscription: xmpp_parsers::roster::Subscription::None,
            ask: xmpp_parsers::roster::Ask::None,
            groups: vec![],
        }],
        ver: None,
    });
    add_roster.id = Some(id.to_string());
    add_roster.into()
}
pub fn make_ask_subscribe(jid: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Subscribe);
    presence.to = Some(jid);

Insertion in src/xmpp/stanzas.rs at line 44 [3.13]

[4.227]

[4.455]

}
pub fn make_chat_message(jid: xmpp_parsers::Jid, text: String) -> Element {
    let mut message = Message::new(Some(jid));
    message.bodies.insert(String::new(), Body(text));
    message.type_ = MessageType::Chat;
    message.into()

Insertion in src/xmpp/mod.rs at line 7 [6.17]
[5.48]
[3.420]
```
use std::collections::{HashMap, VecDeque};
```

Replacement in src/xmpp/mod.rs at line 12 [6.17]

∅:D[7.431] → [2.0:33]

pub struct MaybeXmppConnection {

[7.431]

[8.354]

#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<xmpp_parsers::Jid, (xmpp_parsers::roster::Subscription, Vec<String>)>,
    /// ids counter
    counter: usize,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    /// map from id of adding item to roster and jid of item and message text
    pending_add_roster_ids: HashMap<String, (xmpp_parsers::Jid, String)>,
    /// stanzas to send
    send_queue: VecDeque<minidom::Element>,
================================
    id_init_roster: Option<String>,
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
}
struct XmppState {
    client: Client,
    data: XmppData,
}
struct MaybeXmppConnection {

Replacement in src/xmpp/mod.rs at line 35 [6.17]
∅:D[8.397] → [2.34:61]
```
    inner: Option<Client>,
```
[8.397]
[8.425]
```
    state: Option<XmppState>,
```
Replacement in src/xmpp/mod.rs at line 38 [6.17]
∅:D[9.106] → [2.62:90]
```
pub struct XmppConnection {
```
[9.106]
[10.31]
```
struct XmppConnection {
```
Replacement in src/xmpp/mod.rs at line 40 [6.17]
∅:D[10.74] → [2.91:110]
```
    inner: Client,
```
[10.74]
[8.448]
```
    state: XmppState,
```

Replacement in src/xmpp/mod.rs at line 47 [6.17]

∅:D[8.627] → [2.111:148]

            inner: Some(from.inner),

[8.627]

[11.0]

            state: Some(from.state),

Replacement in src/xmpp/mod.rs at line 52 [6.17]

∅:D[11.19] → [2.149:238]

impl MaybeXmppConnection {
    fn new(account: config::Account) -> MaybeXmppConnection {

[11.19]

[11.132]

impl From<config::Account> for MaybeXmppConnection {
    fn from(from: config::Account) -> MaybeXmppConnection {

Replacement in src/xmpp/mod.rs at line 55 [6.17]

∅:D[11.162] → [2.239:312]

            account: std::rc::Rc::new(account),
            inner: None,

[11.162]

[12.748]

            account: std::rc::Rc::new(from),
            state: None,
        }
    }
}
impl From<std::rc::Rc<config::Account>> for MaybeXmppConnection {
    fn from(from: std::rc::Rc<config::Account>) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from,
            state: None,

Insertion in src/xmpp/mod.rs at line 68 [6.17]
[12.764]
[12.766]
```
}
```
Insertion in src/xmpp/mod.rs at line 70 [6.17]
[12.767]
[6.516]
```
impl MaybeXmppConnection {
```

Replacement in src/xmpp/mod.rs at line 72 [6.17]

∅:D[6.554] → [2.313:359]

    /// don't connect if stop_future resolved

[6.554]

[8.876]

    /// don't connect only if stop_future resolved

Replacement in src/xmpp/mod.rs at line 82 [6.17]

∅:D[6.690] → [2.360:419]

        let MaybeXmppConnection { account, inner } = self;

[6.690]

[6.744]

        let MaybeXmppConnection { account, state } = self;

Replacement in src/xmpp/mod.rs at line 84 [6.17]

∅:D[6.745] → [2.420:577]

        if let Some(inner) = inner {
            Box::new(future::ok(XmppConnection { account, inner }))
                as Box<Future<Item = _, Error = _>>

[6.745]

[6.944]

        if let Some(state) = state {
            Box::new(future::ok(XmppConnection { account, state }))
                as Box<dyn Future<Item = _, Error = _>>

Replacement in src/xmpp/mod.rs at line 94 [6.17]

∅:D[8.1591] → [8.1591:1826]

∅:D[8.1826] → [2.578:651]

∅:D[16.676] → [8.1899:2010]

∅:D[2.651] → [8.1899:2010]

∅:D[8.1899] → [8.1899:2010]

                            let res_client = Client::new(&account.jid, &account.password);
                            match res_client {
                                Err(_e) => Box::new(future::ok(future::Loop::Continue(account)))
                                    as Box<Future<Item = _, Error = _>>,
                                Ok(client) => {
                                    info!("xmpp initialized");

[8.1591]

[6.1476]

                            let client =
                                Client::new_with_jid(account.jid.clone(), &account.password);
                            info!("xmpp initialized");

Replacement in src/xmpp/mod.rs at line 98 [6.17]

∅:D[6.1477] → [7.913:989]

                                    let stop_future2 = stop_future.clone();

[6.1477]

[7.1065]

                            let stop_future2 = stop_future.clone();
                            let stop_future3 = stop_future.clone();

Replacement in src/xmpp/mod.rs at line 101 [6.17]

∅:D[7.1066] → [8.2164:2275]

∅:D[8.2164] → [8.2164:2275]

∅:D[8.2275] → [15.378:435]

∅:D[15.435] → [2.652:711]

∅:D[11.557] → [15.494:589]

∅:D[7.1305] → [15.494:589]

∅:D[13.1072] → [15.494:589]

∅:D[17.556] → [15.494:589]

∅:D[18.493] → [15.494:589]

∅:D[2.711] → [15.494:589]

∅:D[19.307] → [15.494:589]

∅:D[20.387] → [15.494:589]

∅:D[21.400] → [15.494:589]

∅:D[15.494] → [15.494:589]

∅:D[15.589] → [7.1306:1403]

∅:D[7.1403] → [2.712:775]

∅:D[11.621] → [7.1403:1468]

∅:D[17.620] → [7.1403:1468]

∅:D[2.775] → [7.1403:1468]

∅:D[7.1403] → [7.1403:1468]

∅:D[7.1468] → [2.776:867]

∅:D[7.2021] → [15.720:825]

∅:D[13.1481] → [15.720:825]

∅:D[2.867] → [15.720:825]

∅:D[14.231] → [15.720:825]

∅:D[15.720] → [15.720:825]

∅:D[15.825] → [8.2842:3042]

∅:D[8.2842] → [8.2842:3042]

∅:D[8.3042] → [15.826:916]

∅:D[15.916] → [8.3090:3128]

∅:D[8.3090] → [8.3090:3128]

                                    // future to wait for online
                                    Box::new(
                                        XmppConnection {
                                            inner: client,
                                            account,
                                        }
                                        .processing(XmppConnection::online, stop_future.clone())
                                        .map(|(conn, _)| conn)
                                        .map_err(|(acc, _)| acc)
                                        .and_then(|conn| conn.self_presence(stop_future2))
                                        .then(
                                            |r| match r {
                                                Ok(conn) => future::ok(future::Loop::Break(conn)),
                                                Err(acc) => future::ok(future::Loop::Continue(acc)),
                                            },
                                        ),
                                    )

[7.1066]

[8.3128]

                            // future to wait for online
                            Box::new(
                                XmppConnection {
                                    state: XmppState {
                                        client,
                                        data: std::default::Default::default(),
                                    },
                                    account,

Replacement in src/xmpp/mod.rs at line 110 [6.17]

∅:D[8.3162] → [8.3162:3192]

[8.3162]

[8.3192]

                                .processing(XmppConnection::online, stop_future.clone())
                                .map_err(|(acc, _)| acc)
                                .and_then(|(conn, r)| match r {
                                    Ok(Either::A(_)) => future::ok(conn),
                                    Ok(Either::B(_)) => future::err(conn.account),
                                    Err(_e) => future::err(conn.account),
                                })
                                .and_then(|conn| conn.initial_roster(stop_future2))
                                .and_then(|conn| conn.self_presence(stop_future3))
                                .then(|r| match r {
                                    Ok(conn) => future::ok(future::Loop::Break(conn)),
                                    Err(acc) => future::ok(future::Loop::Continue(acc)),
                                }),
                            )

Replacement in src/xmpp/mod.rs at line 142 [6.17]

∅:D[8.3788] → [2.868:970]

    fn xmpp_processing(&mut self, event: &Event) {
        info!("Incoming xmpp event: {:?}", event);

[8.3788]

[7.2124]

    fn xmpp_processing(
        mut self,
        event: &Event,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {
        match event {
            Event::Stanza(stanza) => {
                info!("Incoming xmpp event: {:?}", stanza);
                let stanza = stanza.clone();
                use try_from::TryInto;
                if let Some(iq) = stanza.try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                    if let Some(id) = iq.id {
                        if let Some((_, (jid, message))) =
                            self.state.data.pending_add_roster_ids.remove_entry(&id)
                        {
                            if let xmpp_parsers::iq::IqType::Result(None) = iq.payload {
                                info!("Jid {} added to roster", jid);
                                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&jid) {
                                    rdata.1.push(message);
                                } else {
                                    self.state.data.roster.insert(
                                        jid,
                                        (xmpp_parsers::roster::Subscription::None, vec![message]),
                                    );
                                }
                            } else {
                                warn!(
                                    "Wrong payload when adding {} to roster: {:?}",
                                    jid, iq.payload
                                );
                            }
                        }
                    }
                    if let xmpp_parsers::iq::IqType::Set(element) = iq.payload {
                        if let Some(roster) =
                            element.try_into().ok() as Option<xmpp_parsers::roster::Roster>
                        {
                            for i in roster.items {
                                if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid)
                                {
                                    info!("Update {} in roster", i.jid);
                                    rdata.0 = i.subscription;
                                    if !rdata.1.is_empty() {
                                        let sub_to = match rdata.0 {
                                            xmpp_parsers::roster::Subscription::To => true,
                                            xmpp_parsers::roster::Subscription::Both => true,
                                            _ => false,
                                        };
                                        if sub_to {
                                            info!("Subscribed to {}", i.jid);
                                            let jid = i.jid.clone();
                                            self.state.data.send_queue.extend(
                                                rdata.1.drain(..).map(|message| {
                                                    stanzas::make_chat_message(jid.clone(), message)
                                                }),
                                            )
                                        } else {
                                            info!("Not subscribed to {}", i.jid);
                                            self.state
                                                .data
                                                .send_queue
                                                .push_back(stanzas::make_ask_subscribe(i.jid));
                                        }
                                    }
                                } else {
                                    info!("Add {} to roster", i.jid);
                                    self.state
                                        .data
                                        .roster
                                        .insert(i.jid, (i.subscription, vec![]));
                                }
                            }
                        }
                    }
                }
                future::ok(self)
            }
            Event::Online => future::ok(self),
            e => {
                warn!("Unexpected event {:?}", e);
                future::err(self.account)
            }
        }

Replacement in src/xmpp/mod.rs at line 229 [6.17]

∅:D[8.3983] → [2.971:1007]

    /// or stop future was resolved

[8.3983]

[8.4019]

    /// or stop future was resolved.
    /// Return item if connection was preserved or error otherwise.
    /// Second part is a state of stop_future

Replacement in src/xmpp/mod.rs at line 237 [6.17]

∅:D[8.4137] → [2.1008:1190]

        Item = (Self, Result<Either<F, T>, failure::Error>),
        Error = (
            std::rc::Rc<config::Account>,
            Result<Either<F, T>, failure::Error>,
        ),

[8.4137]

[8.4319]

        Item = (Self, Result<Either<F, T>, E>),
        Error = (std::rc::Rc<config::Account>, Result<Either<F, T>, E>),

Replacement in src/xmpp/mod.rs at line 241 [6.17]

∅:D[8.4335] → [2.1191:1333]

        F: Future<Item = T, Error = E>,
        E: Into<failure::Error>,
        S: FnMut(&mut Self, &Event) -> Result<bool, failure::Error>,

[8.4335]

[8.4476]

        F: Future<Item = T, Error = E> + 'static,
        S: FnMut(&mut Self, Event) -> Result<bool, ()> + 'static,
        T: 'static,
        E: 'static,

Replacement in src/xmpp/mod.rs at line 249 [6.17]

∅:D[8.4612] → [2.1334:2033]

∅:D[2.2033] → [16.5674:5708]

∅:D[16.5674] → [16.5674:5708]

∅:D[16.5708] → [2.2034:2179]

                let XmppConnection { inner, account } = xmpp;
                inner.into_future().select2(stop_future).then(|r| match r {
                    Ok(Either::A(((event, client), b))) => {
                        if let Some(event) = event {
                            let mut xmpp = XmppConnection {
                                inner: client,
                                account,
                            };
                            xmpp.xmpp_processing(&event);
                            match stop_condition(&mut xmpp, &event) {
                                Ok(true) => {
                                    future::ok(future::Loop::Break((xmpp, Ok(Either::A(b)))))
                                }
                                Ok(false) => {
                                    future::ok(future::Loop::Continue((xmpp, b, stop_condition)))

[8.4612]

[16.6443]

                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {:?}", send_element);
                    Box::new(client.send(send_element).select2(stop_future).then(
                        move |r| match r {
                            Ok(Either::A((client, b))) => {
                                Box::new(future::ok(future::Loop::Continue((
                                    XmppConnection {
                                        state: XmppState { client, data },
                                        account,
                                    },
                                    b,
                                    stop_condition,
                                ))))
                                    as Box<dyn Future<Item = _, Error = _>>
                            }
                            Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                Ok(client) => future::ok(future::Loop::Break((
                                    XmppConnection {
                                        state: XmppState { client, data },
                                        account,
                                    },
                                    Ok(Either::B(t)),
                                ))),
                                Err(se) => {
                                    warn!("XMPP sending error: {}", se);
                                    future::err((account, Ok(Either::B(t))))

Replacement in src/xmpp/mod.rs at line 283 [6.17]

∅:D[16.6477] → [2.2180:2259]

                                Err(e) => future::err((xmpp.account, Err(e))),

[16.6477]

[2.2259]

                            })),
                            Err(Either::A((e, b))) => {
                                warn!("XMPP sending error: {}", e);
                                Box::new(future::err((account, Ok(Either::A(b)))))

Replacement in src/xmpp/mod.rs at line 288 [6.17]

∅:D[2.2289] → [2.2289:3480]

                        } else {
                            future::err((account, Ok(Either::A(b))))
                        }
                    }
                    Ok(Either::B((t, a))) => {
                        if let Some(inner) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection { inner, account },
                                Ok(Either::B(t)),
                            )))
                        } else {
                            future::err((account, Ok(Either::B(t))))
                        }
                    }
                    Err(Either::A((_e, b))) => future::err((account, Ok(Either::A(b)))),
                    Err(Either::B((e, a))) => {
                        if let Some(inner) = a.into_inner() {
                            future::ok(future::Loop::Break((
                                XmppConnection { inner, account },
                                Err(e.into()),
                            )))
                        } else {
                            future::err((account, Err(e.into())))
                        }
                    }
                })

[2.2289]

[22.5580]

                            Err(Either::B((e, a))) => Box::new(a.then(|r| match r {
                                Ok(client) => future::ok(future::Loop::Break((
                                    XmppConnection {
                                        state: XmppState { client, data },
                                        account,
                                    },
                                    Err(e),
                                ))),
                                Err(se) => {
                                    warn!("XMPP sending error: {}", se);
                                    future::err((account, Err(e)))
                                }
                            })),
                        },
                    )) as Box<dyn Future<Item = _, Error = _>>
                } else {
                    Box::new(
                        client
                            .into_future()
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A(((event, client), b))) => {
                                    if let Some(event) = event {
                                        let xmpp = XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        };
                                        Box::new(xmpp.xmpp_processing(&event).then(|r| match r {
                                            Ok(mut xmpp) => {
                                                match stop_condition(&mut xmpp, event) {
                                                    Ok(true) => future::ok(future::Loop::Break((
                                                        xmpp,
                                                        Ok(Either::A(b)),
                                                    ))),
                                                    Ok(false) => {
                                                        future::ok(future::Loop::Continue((
                                                            xmpp,
                                                            b,
                                                            stop_condition,
                                                        )))
                                                    }
                                                    Err(_e) => future::err((
                                                        xmpp.account,
                                                        Ok(Either::A(b)),
                                                    )),
                                                }
                                            }
                                            Err(account) => {
                                                future::err((account, Ok(Either::A(b))))
                                            }
                                        }))
                                            as Box<dyn Future<Item = _, Error = _>>
                                    } else {
                                        Box::new(future::err((account, Ok(Either::A(b)))))
                                    }
                                }
                                Ok(Either::B((t, a))) => {
                                    Box::new(if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Ok(Either::B(t)),
                                        )))
                                    } else {
                                        future::err((account, Ok(Either::B(t))))
                                    })
                                }
                                Err(Either::A((e, b))) => {
                                    warn!("XMPP error: {}", e.0);
                                    Box::new(future::err((account, Ok(Either::A(b)))))
                                }
                                Err(Either::B((e, a))) => {
                                    Box::new(if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Err(e),
                                        )))
                                    } else {
                                        future::err((account, Err(e)))
                                    })
                                }
                            }),
                    )
                }

Replacement in src/xmpp/mod.rs at line 382 [6.17]

∅:D[8.6691] → [2.3481:3601]

    /// returns error if something went wrong
    fn online(&mut self, event: &Event) -> Result<bool, failure::Error> {

[8.6691]

[7.4011]

    /// returns error if something went wrong and xmpp connection is broken
    fn online(&mut self, event: Event) -> Result<bool, ()> {

Replacement in src/xmpp/mod.rs at line 395 [6.17]

∅:D[7.4339] → [2.3602:3664]

                Err(format_err!("Disconnected while online"))

[7.4339]

[7.4363]

                Err(())
            }
        }
    }
    fn process_initial_roster(&mut self, event: Event) -> Result<bool, ()> {
        if let Event::Stanza(s) = event {
            use try_from::TryInto;
            match s.try_into() as Result<xmpp_parsers::iq::Iq, _> {
                Ok(iq) => {
                    if let Some(id) = iq.id {
                        if Some(id) == self.state.data.id_init_roster {
                            match iq.payload {
                                xmpp_parsers::iq::IqType::Error(_e) => {
                                    error!("Get error instead of roster");
                                    Err(())
                                }
                                xmpp_parsers::iq::IqType::Result(Some(result)) => {
                                    match result.try_into()
                                        as Result<xmpp_parsers::roster::Roster, _>
                                    {
                                        Ok(roster) => {
                                            self.state.data.roster.clear();
                                            info!("Got first roster:");
                                            for i in roster.items {
                                                info!(" >>> {:?}", i);
                                                self.state
                                                    .data
                                                    .roster
                                                    .insert(i.jid, (i.subscription, vec![]));
                                            }
                                            Ok(true)
                                        }
                                        Err(e) => {
                                            error!("Cann't parse roster: {}", e);
                                            Err(())
                                        }
                                    }
                                }
                                _ => {
                                    error!("Unknown result of roster");
                                    Err(())
                                }
                            }
                        } else {
                            Ok(false)
                        }
                    } else {
                        error!("Iq stanza without id");
                        Err(())
                    }
                }
                Err(_e) => Ok(false),

Insertion in src/xmpp/mod.rs at line 449 [6.17]

[7.4377]

        } else {
            error!("Wrong event while waiting roster");
            Err(())

Insertion in src/xmpp/mod.rs at line 454 [6.17]

[13.8524]


    fn initial_roster<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: 'static,
    {
        let XmppConnection {
            account,
            state: XmppState { client, mut data },
        } = self;
        use tokio::prelude::Sink;

Insertion in src/xmpp/mod.rs at line 469 [6.17]

[13.8525]

[7.7794]

        data.counter += 1;
        let id_init_roster = format!("id_init_roster{}", data.counter);
        let get_roster = stanzas::make_get_roster(&id_init_roster);
        data.id_init_roster = Some(id_init_roster);
        let account2 = account.clone();
        info!("Quering roster... {:?}", get_roster);
        client
            .send(get_roster)
            .map_err(move |e| {
                error!("Error on querying roster: {}", e);
                account2
            })
            .and_then(move |client| {
                XmppConnection {
                    state: XmppState { client, data },
                    account,
                }
                .processing(XmppConnection::process_initial_roster, stop_future)
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }

Replacement in src/xmpp/mod.rs at line 502 [6.17]

∅:D[7.7942] → [2.3665:3728]

        F: Future<Error = E>,
        E: Into<failure::Error>,

[7.7942]

[7.8005]

        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,

Replacement in src/xmpp/mod.rs at line 505 [6.17]

∅:D[7.8011] → [2.3729:3811]

        let XmppConnection { account, inner } = self;
        let client = inner;

[7.8011]

[8.10624]

        let XmppConnection {
            account,
            state: XmppState { client, data },
        } = self;

Deletion in src/xmpp/mod.rs at line 512 [6.17]
∅:D[8.10716] → [2.3812:3850]
```
        info!("Sending presence...");
```
Insertion in src/xmpp/mod.rs at line 513 [6.17]
[8.10756]
[20.6652]
```
        info!("Sending presence... {:?}", presence);
```

Replacement in src/xmpp/mod.rs at line 519 [6.17]

∅:D[7.8315] → [2.3851:3920]

                (account2, Err(failure::SyncFailure::new(e).into()))

[7.8315]

[7.8340]

                account2

Replacement in src/xmpp/mod.rs at line 523 [6.17]

∅:D[7.8426] → [2.3921:3956]

                    inner: client,

[7.8426]

[7.8483]

                    state: XmppState { client, data },

Replacement in src/xmpp/mod.rs at line 529 [6.17]

∅:D[7.8658] → [2.3957:4480]

                            use try_from::TryInto;
                            match s.try_into() as Result<xmpp_parsers::presence::Presence, _> {
                                Ok(presence) => {
                                    Ok(presence.from.as_ref() == Some(&conn.state.client.jid))
                                }
                                Err(e) => {
                                    warn!("Not a self-presence: {}", e);
                                    Ok(false)
                                }

[7.8658]

[7.9042]

                            if s.name() == "presence"
                                && s.attr("from").map_or(false, |f| f == conn.account.jid)
                                && s.attr("to").map_or(false, |f| f == conn.account.jid)
                            {
                                Ok(true)
                            } else {
                                Ok(false)

Replacement in src/xmpp/mod.rs at line 538 [6.17]

∅:D[7.9105] → [2.4481:4569]

                            Err(format_err!("Wrong event while waiting self-presence"))

[7.9105]

[7.9220]

                            error!("Wrong event while waiting self-presence");
                            Err(())

Insertion in src/xmpp/mod.rs at line 544 [6.17]

[7.9320]

[2.4570]

                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })

Replacement in src/xmpp/mod.rs at line 551 [6.17]

∅:D[2.4585] → [2.4585:4823]

∅:D[2.4823] → [17.5310:5325]

∅:D[20.7269] → [17.5310:5325]

∅:D[7.9320] → [17.5310:5325]

            .then(|r| match r {
                Err((account, e)) => {
                    error!("Cann't wait self-presence");
                    future::err(account)
                }
                Ok((conn, _)) => future::ok(conn),
            })

[2.4585]

[8.12130]

    }
    fn process_command(&mut self, cmd: XmppCommand) {
        info!("Got command");
        if let Some(ref mut rdata) = self.state.data.roster.get_mut(&cmd.xmpp_to) {
            info!("Jid {} in roster", cmd.xmpp_to);
            let sub_to = match rdata.0 {
                xmpp_parsers::roster::Subscription::To => true,
                xmpp_parsers::roster::Subscription::Both => true,
                _ => false,
            };
            if sub_to {
                info!("Subscribed to {}", cmd.xmpp_to);
                self.state
                    .data
                    .send_queue
                    .push_back(stanzas::make_chat_message(cmd.xmpp_to, cmd.message));
            } else {
                info!("Not subscribed to {}", cmd.xmpp_to);
                rdata.1.push(cmd.message);
                self.state
                    .data
                    .send_queue
                    .push_back(stanzas::make_ask_subscribe(cmd.xmpp_to));
            }
        } else {
            info!("Jid {} not in roster", cmd.xmpp_to);
            self.state.data.counter += 1;
            let id_add_roster = format!("id_add_roster{}", self.state.data.counter);
            let add_roster = stanzas::make_add_roster(&id_add_roster, cmd.xmpp_to.clone());
            self.state
                .data
                .pending_add_roster_ids
                .insert(id_add_roster, (cmd.xmpp_to, cmd.message));
            info!("Adding jid to roster... {:?}", add_roster);
            self.state.data.send_queue.push_back(add_roster);
        }

Replacement in src/xmpp/mod.rs at line 594 [6.17]

∅:D[23.60] → [2.4824:4848]

pub struct XmppCommand;

[23.60]

[6.3816]

pub struct XmppCommand {
    pub xmpp_to: xmpp_parsers::Jid,
    pub message: String,
}

Replacement in src/xmpp/mod.rs at line 599 [6.17]
∅:D[6.3817] → [2.4849:4874]
```
struct XmppState<F, S> {
```
[6.3817]
[23.86]
```
struct XmppProcessState<F, S> {
```

Replacement in src/xmpp/mod.rs at line 605 [6.17]

∅:D[6.3920] → [2.4875:5007]

impl<F, S> XmppState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppState<F, S> {
        XmppState {

[6.3920]

[6.4058]

impl<F, S> XmppProcessState<F, S> {
    fn new(cmd_recv: S, signal: F, conn: MaybeXmppConnection) -> XmppProcessState<F, S> {
        XmppProcessState {

Replacement in src/xmpp/mod.rs at line 625 [6.17]
∅:D[6.4357] → [2.5008:5058]
```
    let conn = MaybeXmppConnection::new(account);
```
[6.4357]
[6.4526]
```
    let conn = account.into();
```

Replacement in src/xmpp/mod.rs at line 627 [6.17]

∅:D[6.4527] → [2.5059:5149]

    future::loop_fn(XmppState::new(cmd_recv, signal, conn), |s| {
        let XmppState {

[6.4527]

[6.4617]

    future::loop_fn(XmppProcessState::new(cmd_recv, signal, conn), |s| {
        let XmppProcessState {

Replacement in src/xmpp/mod.rs at line 633 [6.17]

∅:D[6.4692] → [2.5150:6170]

        conn.connect(signal.clone())
            .and_then(|conn| {
                info!("xmpp connected!");
                cmd_recv
                    .into_future()
                    .map_err(|_| {
                        error!("Got error on recv cmd");
                        format_err!("Receive cmd error")
                    })
                    .map(|(cmd, cmd_recv)| (cmd, cmd_recv, conn))
            })
            .then(|r| {
                match r {
                    Ok((cmd, cmd_recv, conn)) => {
                        if let Some(_cmd) = cmd {
                            info!("Got cmd");
                            // got cmd, continue
                            future::ok(future::Loop::Continue(XmppState::new(
                                cmd_recv,
                                signal,
                                conn.into(),
                            )))
                        } else {
                            future::ok(future::Loop::Break((None, conn.into())))

[6.4692]

[12.8118]

        conn.connect(signal.clone()).and_then(|conn| {
            info!("xmpp connected!");
            conn.processing(|_, _| Ok(false), cmd_recv.into_future())
                .then(|r| match r {
                    Ok((mut conn, r)) => match r {
                        Ok(Either::A(f)) => {
                            if let Some(cmd_recv) = f.into_inner() {
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: conn.into(),
                                }))
                            } else {
                                future::err(format_err!("Command receiver is gone"))
                            }
                        }
                        Ok(Either::B((cmd, cmd_recv))) => {
                            if let Some(cmd) = cmd {
                                conn.process_command(cmd);
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: conn.into(),
                                }))
                            } else {
                                future::ok(future::Loop::Break(()))
                            }
                        }
                        Err(_) => future::err(format_err!("Command receiver is broken")),
                    },
                    Err((account, r)) => match r {
                        Ok(Either::A(f)) => {
                            if let Some(cmd_recv) = f.into_inner() {
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: account.into(),
                                }))
                            } else {
                                future::err(format_err!("Command receiver is gone"))
                            }
                        }
                        Ok(Either::B((cmd, cmd_recv))) => {
                            if let Some(_cmd) = cmd {
                                error!("Xmpp connection broken while get command");
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: account.into(),
                                }))
                            } else {
                                future::ok(future::Loop::Break(()))
                            }

Replacement in src/xmpp/mod.rs at line 688 [6.17]

∅:D[12.8144] → [2.6171:6444]

                    }
                    Err(e) => {
                        // got cmd error, its bad
                        error!("Cmd error: {}", e);
                        future::err(format_err!("Cmd error"))
                    }
                }
            })

[12.8144]

[2.6444]

                        Err(_) => future::err(format_err!("Command receiver is broken")),
                    },
                })
        })

Deletion in src/xmpp/mod.rs at line 693 [6.17]

∅:D[2.6451] → [2.6451:6957]

∅:D[11.8876] → [7.10245:10252]

∅:D[24.5939] → [7.10245:10252]

∅:D[17.9312] → [7.10245:10252]

∅:D[18.8180] → [7.10245:10252]

∅:D[12.8916] → [7.10245:10252]

∅:D[2.6957] → [7.10245:10252]

∅:D[7.10245] → [7.10245:10252]

    .and_then(|(opt_cmd_recv, _conn): (Option<S>, MaybeXmppConnection)| {
        if let Some(cmd_recv) = opt_cmd_recv {
            // process left commands
            info!("Stop accepting commands");
            Box::new(
                cmd_recv
                    .for_each(|_cmd| future::ok(()))
                    .map_err(|_| format_err!("cmd receiver last error")),
            ) as Box<Future<Item = (), Error = failure::Error>>
        } else {
            Box::new(future::ok(()))
        }
    })

Insertion in src/main.rs at line 2 [25.17]
[10.3556]
[10.3556]
```
#![deny(bare_trait_objects)]
```
Deletion in src/main.rs at line 8 [25.17]
∅:D[10.3621] → [2.6958:6980]
```
extern crate minidom;
```
Deletion in src/main.rs at line 22 [25.17]
∅:D[10.3921] → [2.6981:7013]
```
use hyper::service::service_fn;
```
Replacement in src/main.rs at line 27 [25.17]
∅:D[10.4066] → [2.7014:7040]
```
use tokio::prelude::Sink;
```
[10.4066]
[10.4092]
```
use tokio::prelude::{Future, Sink, Stream};
```

Insertion in src/main.rs at line 37 [25.17]

[10.4260]

[26.9738]


struct ServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
impl hyper::service::Service for ServiceCmd {
    type ReqBody = Body;
    type ResBody = Body;
    type Error = failure::Error;
    type Future =
        Box<dyn Future<Item = Response<Self::ResBody>, Error = Self::Error> + Send + 'static>;
    fn call(&mut self, req: Request<Self::ReqBody>) -> Self::Future {
        let xmpp_to_opt = req.headers().get("X-XMPP-To");
        let xmpp_to_res: Result<xmpp_parsers::Jid, failure::Error> = xmpp_to_opt.map_or_else(
            || Err(format_err!("No X-XMPP-To header")),
            |xmpp_to| {
                std::str::from_utf8(xmpp_to.as_bytes())
                    .map_err(|e| e.into())
                    .and_then(|s| {
                        std::str::FromStr::from_str(s)
                            .map_err(|e: xmpp_parsers::JidParseError| e.into())
                    })
            },
        );
        match xmpp_to_res {
            Err(err) => {
                warn!("Unknown destination: {}", err);
                Box::new(tokio::prelude::future::result(
                    Response::builder()
                        .status(hyper::StatusCode::BAD_REQUEST)
                        .body(Body::from(format!("Unknown destination: {}", err)))
                        .map_err(|e| e.into()),
                )) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
            Ok(xmpp_to) => {
                info!("Got request. Reading body...");
                let cmd_send = self.cmd_send.clone();
                Box::new(
                    req.into_body()
                        .map_err(|e| e.into())
                        .fold(String::new(), |mut acc, ch| {
                            std::str::from_utf8(&*ch).map(|s| {
                                acc.push_str(s);
                                acc
                            })
                        })
                        .and_then(move |message: String| {
                            if !message.is_empty() {
                                Box::new(
                                    cmd_send
                                        .clone()
                                        .send(XmppCommand { xmpp_to, message })
                                        .then(|r| match r {
                                            Ok(_) => tokio::prelude::future::ok(Response::new(
                                                Body::from("Accepted"),
                                            )),
                                            Err(e) => {
                                                error!("Command sent error: {}", e);
                                                tokio::prelude::future::result(
                                                    Response::builder()
                                                        .status(hyper::StatusCode::BAD_REQUEST)
                                                        .body(Body::from(format!(
                                                            "Command sent error: {}",
                                                            e
                                                        ))),
                                                )
                                            }
                                        })
                                        .map_err(|e| e.into()),
                                )
                            } else {
                                warn!("Empty message");
                                Box::new(tokio::prelude::future::result(
                                    Response::builder()
                                        .status(hyper::StatusCode::BAD_REQUEST)
                                        .body(Body::from("Empty message"))
                                        .map_err(|e| e.into()),
                                ))
                                    as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                            }
                        }),
                ) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
        }
    }
}
struct MakeServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}

Insertion in src/main.rs at line 130 [25.17]

[26.9739]

[25.18]

impl<Ctx> hyper::service::MakeService<Ctx> for MakeServiceCmd {
    type ReqBody = Body;
    type ResBody = Body;
    type Error = failure::Error;
    type Service = ServiceCmd;
    type Future = tokio::prelude::future::FutureResult<ServiceCmd, Self::MakeError>;
    type MakeError = hyper::http::Error;
    fn make_service(&mut self, _ctx: Ctx) -> Self::Future {
        tokio::prelude::future::ok(ServiceCmd {
            cmd_send: self.cmd_send.clone(),
        })
    }
}

Replacement in src/main.rs at line 178 [25.17]

∅:D[10.5155] → [2.7041:7821]

        .serve(move || {
            let cmd_send = cmd_send.clone();
            service_fn(move |_req: Request<Body>| {
                info!("Got request");
                cmd_send.clone().send(XmppCommand {}).then(|r| match r {
                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from("Accepted"))),
                    Err(e) => {
                        error!("Command sent error: {}", e);
                        tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from(format!("Command sent error: {}", e))),
                        )
                    }
                })
            })
        })

[10.5155]

[10.5935]

        .serve(MakeServiceCmd { cmd_send })

Replacement in src/config.rs at line 6 [27.1396]

∅:D[27.1502] → [27.1502:1523]

    pub jid: String,

[27.1502]

[27.1523]

    #[serde(deserialize_with = "deserialize_jid")]
    pub jid: xmpp_parsers::Jid,

Insertion in src/config.rs at line 26 [27.1396]

[27.1943]

}
fn deserialize_jid<'de, D>(deserializer: D) -> Result<xmpp_parsers::Jid, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::Deserialize;
    let s = String::deserialize(deserializer)?;
    std::str::FromStr::from_str(&s).map_err(serde::de::Error::custom)

Replacement in Cargo.toml at line 12 [25.11995]
∅:D[10.6900] → [2.7822:7857]
```
tokio-xmpp = "0.2"
failure = "0.1"
```
[10.6900]
[10.6935]
```
tokio-xmpp = "0.2.3"
failure = "0.1.5"
```

Replacement in Cargo.toml at line 21 [25.11995]

∅:D[10.7043] → [2.7858:7927]

minidom = "=0.9.1" # dependency of tokio-xmpp
xmpp-parsers = "0.11"

[10.7043]

xmpp-parsers = "0.12.2"
minidom = "=0.10.0" # xmpp-parsers
try_from = "=0.3.2" # xmpp-parsers

Insertion in Cargo.lock at line 0 [25.12201]

[25.12201]

[10.7113]

[[package]]
name = "MacTypes-sys"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
]

Replacement in Cargo.lock at line 13 [25.12201]

∅:D[10.7247] → [2.7928:8001]

 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",

[10.7247]

[10.7320]

 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 26 [25.12201]
∅:D[10.7561] → [2.8002:8020]
```
version = "0.3.6"
```
[10.7561]
[2.8020]
```
version = "0.3.7"
```
Deletion in Cargo.lock at line 30 [25.12201]
∅:D[2.8098] → [2.8098:8134]
∅:D[16.14499] → [10.7579:7657]
∅:D[28.1168] → [10.7579:7657]
∅:D[26.10181] → [10.7579:7657]
∅:D[29.7929] → [10.7579:7657]
∅:D[2.8134] → [10.7579:7657]
∅:D[8.13682] → [10.7579:7657]
∅:D[30.4857] → [10.7579:7657]
∅:D[31.5772] → [10.7579:7657]
∅:D[10.7579] → [10.7579:7657]
```
name = "arrayref"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
```
Replacement in Cargo.lock at line 31 [25.12201]
∅:D[10.7789] → [2.8135:8153]
```
version = "0.4.8"
```
[10.7789]
[10.7807]
```
version = "0.4.10"
```

Replacement in Cargo.lock at line 42 [25.12201]

∅:D[10.8093] → [2.8154:8226]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",

[10.8093]

[10.8165]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 48 [25.12201]
∅:D[26.10388] → [2.8227:8264]
```
name = "backtrace"
version = "0.2.3"
```
[26.10388]
[10.8364]
```
name = "autocfg"
version = "0.1.2"
```

Deletion in Cargo.lock at line 51 [25.12201]

∅:D[10.8429] → [2.8265:8821]

dependencies = [
 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]

Replacement in Cargo.lock at line 54 [25.12201]
∅:D[10.9017] → [2.8822:8840]
```
version = "0.3.9"
```
[10.9017]
[10.9035]
```
version = "0.3.13"
```

Replacement in Cargo.lock at line 57 [25.12201]

∅:D[10.9117] → [2.8841:8922]

 "backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)",

[10.9117]

[10.9198]

 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 60 [25.12201]

∅:D[10.9271] → [2.8923:9076]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",

[10.9271]

[10.9424]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 67 [25.12201]
∅:D[10.9535] → [2.9077:9096]
```
version = "0.1.24"
```
[10.9535]
[10.9554]
```
version = "0.1.28"
```

Replacement in Cargo.lock at line 70 [25.12201]

∅:D[10.9636] → [2.9097:9239]

 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",

[10.9636]

[10.9778]

 "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 76 [25.12201]
∅:D[10.9809] → [2.9240:9258]
```
version = "0.9.3"
```
[10.9809]
[10.9827]
```
version = "0.10.0"
```

Replacement in Cargo.lock at line 79 [25.12201]

∅:D[10.9909] → [2.9259:9409]

 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",

[10.9909]

[10.10059]

 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 89 [25.12201]
∅:D[10.10204] → [2.9410:9428]
```
version = "0.7.1"
```
[10.10204]
[10.10222]
```
version = "0.8.0"
```

Replacement in Cargo.lock at line 92 [25.12201]

∅:D[10.10304] → [2.9429:9656]

 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",

[10.10304]

[10.10531]

 "byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 100 [25.12201]

∅:D[10.10568] → [2.9657:9675]

version = "0.3.3"

[10.10568]

[16.15564]

version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "block-padding 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "block-padding"
version = "0.1.2"

Replacement in Cargo.lock at line 114 [25.12201]

∅:D[16.15646] → [2.9676:9828]

 "arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",

[16.15646]

[16.15960]

 "byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 119 [25.12201]
∅:D[10.10855] → [2.9829:9847]
```
version = "0.2.0"
```
[10.10855]
[10.10873]
```
version = "0.3.0"
```
Replacement in Cargo.lock at line 124 [25.12201]
∅:D[10.10970] → [2.9848:9866]
```
version = "1.2.7"
```
[10.10970]
[10.10988]
```
version = "1.3.0"
```

Replacement in Cargo.lock at line 132 [25.12201]

∅:D[10.11182] → [2.9867:9943]

 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",

[10.11182]

[10.11258]

 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 143 [25.12201]
∅:D[10.11467] → [2.9944:9963]
```
version = "1.0.25"
```
[10.11467]
[10.11486]
```
version = "1.0.28"
```

Replacement in Cargo.lock at line 158 [25.12201]

∅:D[10.11948] → [2.9964:10036]

 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",

[10.11948]

[10.12020]

 "time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",

Deletion in Cargo.lock at line 182 [25.12201]

∅:D[10.12887] → [2.10037:10159]


[[package]]
name = "constant_time_eq"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"

Replacement in Cargo.lock at line 189 [25.12201]

∅:D[10.13233] → [2.10160:10232]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",

[10.13233]

[10.13305]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 197 [25.12201]

∅:D[16.16590] → [2.10233:10305]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",

[16.16590]

[10.13521]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "crossbeam-channel"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 213 [25.12201]
∅:D[10.13561] → [2.10306:10324]
```
version = "0.6.2"
```
[10.13561]
[10.13579]
```
version = "0.6.3"
```

Replacement in Cargo.lock at line 216 [25.12201]

∅:D[10.13661] → [2.10325:10489]

 "crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",

[10.13661]

[10.13825]

 "crossbeam-epoch 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 222 [25.12201]
∅:D[10.13865] → [2.10490:10508]
```
version = "0.6.1"
```
[10.13865]
[10.13883]
```
version = "0.7.0"
```

Replacement in Cargo.lock at line 225 [25.12201]

∅:D[10.13965] → [2.10509:10584]

 "arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",

[10.13965]

[10.14040]

 "arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 227 [25.12201]

∅:D[10.14113] → [2.10585:10667]

 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",

[10.14113]

[10.14195]

 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 235 [25.12201]
∅:D[10.14466] → [2.10668:10686]
```
version = "0.6.1"
```
[10.14466]
[10.14484]
```
version = "0.6.3"
```
Replacement in Cargo.lock at line 243 [25.12201]
∅:D[10.14674] → [2.10687:10705]
```
version = "0.5.2"
```
[10.14674]
[2.10705]
```
version = "0.7.0"
```

Replacement in Cargo.lock at line 246 [25.12201]

∅:D[2.10787] → [2.10787:10950]

 "constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",

[2.10787]

[2.10950]

 "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "subtle 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",

Deletion in Cargo.lock at line 251 [25.12201]
∅:D[2.10965] → [2.10965:11004]
∅:D[16.17297] → [10.14692:14774]
∅:D[2.11004] → [10.14692:14774]
∅:D[10.14692] → [10.14692:14774]
∅:D[10.14774] → [2.11005:11157]
∅:D[16.17452] → [10.14937:14952]
∅:D[2.11157] → [10.14937:14952]
∅:D[10.14937] → [10.14937:14952]
```
name = "dbghelp-sys"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
```
Replacement in Cargo.lock at line 262 [25.12201]
∅:D[10.15609] → [2.11158:11176]
```
version = "0.7.6"
```
[10.15609]
[10.15627]
```
version = "0.8.0"
```

Replacement in Cargo.lock at line 265 [25.12201]

∅:D[10.15709] → [2.11177:11257]

 "generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",

[10.15709]

[10.15789]

 "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 270 [25.12201]
∅:D[10.15825] → [2.11258:11277]
```
version = "0.8.12"
```
[10.15825]
[10.15844]
```
version = "0.8.14"
```

Replacement in Cargo.lock at line 284 [25.12201]

∅:D[10.16352] → [2.11278:11350]

 "regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",

[10.16352]

[10.16424]

 "regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",

Deletion in Cargo.lock at line 290 [25.12201]

∅:D[10.16536] → [2.11351:11564]

version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "error-chain"

Replacement in Cargo.lock at line 293 [25.12201]

∅:D[10.16849] → [2.11565:11641]

 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",

[10.16849]

[10.16925]

 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 298 [25.12201]
∅:D[10.16957] → [2.11642:11660]
```
version = "0.1.3"
```
[10.16957]
[10.16975]
```
version = "0.1.5"
```

Replacement in Cargo.lock at line 301 [25.12201]

∅:D[10.17057] → [2.11661:11818]

 "backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",

[10.17057]

[10.17214]

 "backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 307 [25.12201]
∅:D[10.17253] → [2.11819:11837]
```
version = "0.1.3"
```
[10.17253]
[10.17271]
```
version = "0.1.5"
```

Replacement in Cargo.lock at line 310 [25.12201]

∅:D[10.17353] → [2.11838:12062]

 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",

[10.17353]

[10.17577]

 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 373 [25.12201]

∅:D[10.19271] → [2.12063:12138]

 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",

[10.19271]

[10.19346]

 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 378 [25.12201]
∅:D[10.19384] → [2.12139:12157]
```
version = "0.9.0"
```
[10.19384]
[10.19402]
```
version = "0.12.0"
```
Replacement in Cargo.lock at line 386 [25.12201]
∅:D[10.19586] → [2.12158:12177]
```
version = "0.1.14"
```
[10.19586]
[10.19605]
```
version = "0.1.15"
```

Replacement in Cargo.lock at line 389 [25.12201]

∅:D[10.19687] → [2.12178:12254]

 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",

[10.19687]

[10.19763]

 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 396 [25.12201]

∅:D[10.20198] → [2.12255:12475]

 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",

[10.20198]

[16.18560]

 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "hmac"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 415 [25.12201]

∅:D[10.20551] → [2.12476:12548]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",

[10.20551]

[10.20623]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 444 [25.12201]
∅:D[10.21397] → [2.12549:12569]
```
version = "0.12.17"
```
[10.21397]
[10.21417]
```
version = "0.12.21"
```

Replacement in Cargo.lock at line 450 [25.12201]

∅:D[10.21729] → [2.12570:12640]

 "h2 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",

[10.21729]

[10.21799]

 "h2 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 457 [25.12201]

∅:D[10.22231] → [2.12641:13182]

 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",

[10.22231]

[10.22772]

 "time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 488 [25.12201]

∅:D[10.23535] → [2.13183:13255]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",

[10.23535]

[10.23607]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 511 [25.12201]
∅:D[10.24326] → [2.13256:13274]
```
version = "0.5.2"
```
[10.24326]
[10.24344]
```
version = "0.5.3"
```

Replacement in Cargo.lock at line 514 [25.12201]

∅:D[10.24426] → [2.13275:13504]

 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",

[10.24426]

[10.24655]

 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 545 [25.12201]
∅:D[10.25316] → [2.13505:13524]
```
version = "0.2.44"
```
[10.25316]
[10.25335]
```
version = "0.2.47"
```
Replacement in Cargo.lock at line 585 [25.12201]
∅:D[10.26368] → [2.13525:13543]
```
version = "0.7.3"
```
[10.26368]
[10.26386]
```
version = "0.7.5"
```

Replacement in Cargo.lock at line 588 [25.12201]

∅:D[10.26468] → [2.13544:13925]

 "phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",

[10.26468]

[10.26849]

 "phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 595 [25.12201]

∅:D[10.27015] → [2.13926:14000]

 "tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",

[10.27015]

[10.27089]

 "tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 605 [25.12201]
∅:D[10.27233] → [2.14001:14019]
```
version = "2.1.1"
```
[10.27233]
[10.27251]
```
version = "2.1.3"
```

Replacement in Cargo.lock at line 609 [25.12201]

∅:D[10.27406] → [2.14020:14172]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",

[10.27406]

[10.27558]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 619 [25.12201]
∅:D[10.27705] → [2.14173:14191]
```
version = "0.9.1"
```
[10.27705]
[10.27723]
```
version = "0.10.0"
```

Replacement in Cargo.lock at line 622 [25.12201]

∅:D[10.27805] → [2.14192:14424]

 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",

[10.27805]

[10.28037]

 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 637 [25.12201]

∅:D[10.28558] → [2.14425:14497]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",

[10.28558]

[10.28630]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 641 [25.12201]

∅:D[10.28843] → [2.14498:14569]

 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",

[10.28843]

[10.28914]

 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 651 [25.12201]

∅:D[10.29191] → [2.14570:14642]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",

[10.29191]

[10.29263]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 672 [25.12201]

∅:D[10.29977] → [2.14643:14715]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",

[10.29977]

[10.30049]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 674 [25.12201]

∅:D[10.30119] → [2.14716:14792]

 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",

[10.30119]

[10.30195]

 "openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 676 [25.12201]

∅:D[10.30275] → [2.14793:14872]

 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",

[10.30275]

[10.30354]

 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 678 [25.12201]

∅:D[10.30430] → [2.14873:15047]

 "security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",

[10.30430]

[10.30604]

 "security-framework 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 689 [25.12201]

∅:D[10.30882] → [2.15048:15120]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",

[10.30882]

[10.30954]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 721 [25.12201]
∅:D[10.31727] → [2.15121:15139]
```
version = "1.8.0"
```
[10.31727]
[10.31745]
```
version = "1.9.0"
```

Replacement in Cargo.lock at line 724 [25.12201]

∅:D[10.31827] → [2.15140:15212]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",

[10.31827]

[10.31899]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",

Insertion in Cargo.lock at line 728 [25.12201]

[10.31914]

name = "opaque-debug"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]

Replacement in Cargo.lock at line 734 [25.12201]
∅:D[10.31931] → [2.15213:15233]
```
version = "0.10.15"
```
[10.31931]
[10.31951]
```
version = "0.10.16"
```

Replacement in Cargo.lock at line 741 [25.12201]

∅:D[10.32339] → [2.15234:15385]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",

[10.32339]

[10.32490]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 752 [25.12201]
∅:D[10.32645] → [2.15386:15405]
```
version = "0.9.39"
```
[10.32645]
[10.32664]
```
version = "0.9.40"
```

Replacement in Cargo.lock at line 755 [25.12201]

∅:D[10.32746] → [2.15406:15548]

 "cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",

[10.32746]

[10.32888]

 "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 771 [25.12201]
∅:D[10.33294] → [2.15549:15567]
```
version = "0.6.4"
```
[10.33294]
[10.33312]
```
version = "0.7.1"
```

Replacement in Cargo.lock at line 775 [25.12201]

∅:D[10.33469] → [2.15568:15651]

 "parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",

[10.33469]

[10.33552]

 "parking_lot_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 780 [25.12201]
∅:D[10.33593] → [2.15652:15670]
```
version = "0.3.1"
```
[10.33593]
[10.33611]
```
version = "0.4.0"
```

Replacement in Cargo.lock at line 783 [25.12201]

∅:D[10.33693] → [2.15671:15814]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",

[10.33693]

[10.33836]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 786 [25.12201]

∅:D[10.33916] → [2.15815:15890]

 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",

[10.33916]

[10.33991]

 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",

Insertion in Cargo.lock at line 791 [25.12201]

[10.34079]

name = "pbkdf2"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]

Replacement in Cargo.lock at line 806 [25.12201]
∅:D[10.34214] → [2.15891:15910]
```
version = "0.7.23"
```
[10.34214]
[10.34233]
```
version = "0.7.24"
```

Replacement in Cargo.lock at line 809 [25.12201]

∅:D[10.34315] → [2.15911:15989]

 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",

[10.34315]

[10.34393]

 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 814 [25.12201]
∅:D[10.34429] → [2.15990:16009]
```
version = "0.7.23"
```
[10.34429]
[10.34448]
```
version = "0.7.24"
```

Replacement in Cargo.lock at line 817 [25.12201]

∅:D[10.34530] → [2.16010:16169]

 "phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",

[10.34530]

[10.34689]

 "phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 823 [25.12201]
∅:D[10.34727] → [2.16170:16189]
```
version = "0.7.23"
```
[10.34727]
[10.34746]
```
version = "0.7.24"
```

Replacement in Cargo.lock at line 826 [25.12201]

∅:D[10.34828] → [2.16190:16339]

 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",

[10.34828]

[10.34977]

 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 832 [25.12201]
∅:D[10.35012] → [2.16340:16359]
```
version = "0.7.23"
```
[10.35012]
[10.35031]
```
version = "0.7.24"
```
Replacement in Cargo.lock at line 850 [25.12201]
∅:D[10.35464] → [2.16360:16379]
```
version = "0.4.24"
```
[10.35464]
[10.35483]
```
version = "0.4.26"
```
Replacement in Cargo.lock at line 863 [25.12201]
∅:D[10.35794] → [2.16380:16399]
```
version = "0.12.4"
```
[10.35794]
[10.35813]
```
version = "0.13.2"
```

Replacement in Cargo.lock at line 866 [25.12201]

∅:D[10.35895] → [2.16400:16553]

 "encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",

[10.35895]

[10.36048]

 "encoding_rs 0.8.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 869 [25.12201]

∅:D[10.36118] → [2.16554:16627]

 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",

[10.36118]

[10.36191]

 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 879 [25.12201]
∅:D[10.36333] → [2.16628:16647]
```
version = "0.6.10"
```
[10.36333]
[2.16647]
```
version = "0.6.11"
```

Replacement in Cargo.lock at line 882 [25.12201]

∅:D[2.16729] → [2.16729:16808]

 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",

[2.16729]

[2.16808]

 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",

Deletion in Cargo.lock at line 887 [25.12201]

∅:D[2.16837] → [2.16837:16855]

∅:D[16.23338] → [10.36560:36642]

∅:D[2.16855] → [10.36560:36642]

∅:D[10.36560] → [10.36560:36642]

∅:D[10.36642] → [2.16856:17082]

∅:D[16.23418] → [10.36868:36897]

∅:D[2.17082] → [10.36868:36897]

∅:D[10.36868] → [10.36868:36897]

version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand"

Replacement in Cargo.lock at line 892 [25.12201]

∅:D[10.37153] → [2.17083:17155]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",

[10.37153]

[10.37225]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 899 [25.12201]
∅:D[10.37392] → [2.17156:17174]
```
version = "0.6.1"
```
[10.37392]
[10.37410]
```
version = "0.6.4"
```

Replacement in Cargo.lock at line 902 [25.12201]

∅:D[10.37492] → [2.17175:17481]

 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",

[10.37492]

[10.37798]

 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",

Insertion in Cargo.lock at line 908 [25.12201]

[10.38025]

 "rand_os 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 910 [25.12201]

∅:D[10.38100] → [2.17482:17642]

 "rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",

[10.38100]

[10.38260]

 "rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 916 [25.12201]
∅:D[10.38369] → [2.17643:17661]
```
version = "0.1.0"
```
[10.38369]
[10.38387]
```
version = "0.1.1"
```

Insertion in Cargo.lock at line 919 [25.12201]

[10.38469]

 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",

Deletion in Cargo.lock at line 921 [25.12201]

∅:D[10.38545] → [2.17662:17742]

 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",

Insertion in Cargo.lock at line 953 [25.12201]

[16.24177]

[10.39384]

name = "rand_os"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]

Replacement in Cargo.lock at line 976 [25.12201]

∅:D[10.39696] → [2.17743:17761]

version = "0.1.0"

[10.39696]

[10.39714]

version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rdrand"
version = "0.4.0"

Replacement in Cargo.lock at line 992 [25.12201]
∅:D[10.39910] → [2.17762:17781]
```
version = "0.1.43"
```
[10.39910]
[10.39929]
```
version = "0.1.51"
```

Replacement in Cargo.lock at line 1000 [25.12201]

∅:D[10.40130] → [2.17782:17863]

 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",

[10.40130]

[10.40211]

 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1005 [25.12201]
∅:D[10.40241] → [2.17864:17882]
```
version = "1.0.6"
```
[10.40241]
[10.40259]
```
version = "1.1.0"
```

Replacement in Cargo.lock at line 1009 [25.12201]

∅:D[10.40420] → [2.17883:18035]

 "memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",

[10.40420]

[10.40572]

 "memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1017 [25.12201]
∅:D[10.40766] → [2.18036:18054]
```
version = "0.6.3"
```
[10.40766]
[10.40784]
```
version = "0.6.4"
```
Replacement in Cargo.lock at line 1033 [25.12201]
∅:D[10.41189] → [2.18055:18073]
```
version = "0.6.1"
```
[10.41189]
[10.41207]
```
version = "0.6.2"
```
Replacement in Cargo.lock at line 1042 [25.12201]
∅:D[10.41481] → [2.18074:18092]
```
version = "0.1.9"
```
[10.41481]
[10.41499]
```
version = "0.1.13"
```

Deletion in Cargo.lock at line 1059 [25.12201]

∅:D[10.41897] → [2.18093:18206]

name = "safemem"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]

Replacement in Cargo.lock at line 1060 [25.12201]
∅:D[10.42024] → [2.18207:18225]
```
version = "0.4.2"
```
[10.42024]
[10.42042]
```
version = "0.4.3"
```

Replacement in Cargo.lock at line 1063 [25.12201]

∅:D[10.42124] → [2.18226:18375]

 "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)",

[10.42124]

[10.42273]

 "base64 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "hmac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "pbkdf2 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1087 [25.12201]
∅:D[10.42717] → [2.18376:18394]
```
version = "0.2.1"
```
[10.42717]
[10.42735]
```
version = "0.2.2"
```

Replacement in Cargo.lock at line 1092 [25.12201]

∅:D[10.42985] → [2.18395:18556]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",

[10.42985]

[10.43146]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1098 [25.12201]
∅:D[10.43193] → [2.18557:18575]
```
version = "0.2.1"
```
[10.43193]
[10.43211]
```
version = "0.2.3"
```

Insertion in Cargo.lock at line 1101 [25.12201]

[10.43293]

 "MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1103 [25.12201]

∅:D[10.43379] → [2.18576:18648]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",

[10.43379]

[10.43451]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1125 [25.12201]

∅:D[10.43981] → [2.18649:18797]

 "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)",

[10.43981]

[10.44129]

 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.21 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1128 [25.12201]

∅:D[10.44199] → [2.18798:19098]

 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",

[10.44199]

[10.44499]

 "minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1134 [25.12201]

∅:D[10.44658] → [2.19099:19176]

 "tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",

[10.44658]

[10.44735]

 "tokio-xmpp 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1136 [25.12201]

∅:D[10.44807] → [2.19177:19257]

 "xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)",

[10.44807]

[10.44887]

 "try_from 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1142 [25.12201]
∅:D[10.44917] → [2.19258:19277]
```
version = "1.0.80"
```
[10.44917]
[10.44936]
```
version = "1.0.85"
```
Replacement in Cargo.lock at line 1147 [25.12201]
∅:D[10.45036] → [2.19278:19297]
```
version = "1.0.80"
```
[10.45036]
[10.45055]
```
version = "1.0.85"
```

Replacement in Cargo.lock at line 1150 [25.12201]

∅:D[10.45137] → [2.19298:19522]

 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",

[10.45137]

[10.45361]

 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1157 [25.12201]
∅:D[10.45396] → [2.19523:19542]
```
version = "1.0.33"
```
[10.45396]
[10.45415]
```
version = "1.0.36"
```

Replacement in Cargo.lock at line 1162 [25.12201]

∅:D[10.45638] → [2.19543:19616]

 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",

[10.45638]

[10.45711]

 "serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1167 [25.12201]
∅:D[10.45741] → [2.19617:19635]
```
version = "0.7.0"
```
[10.45741]
[10.45759]
```
version = "0.8.1"
```

Replacement in Cargo.lock at line 1170 [25.12201]

∅:D[10.45841] → [2.19636:19865]

 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",

[10.45841]

[10.46070]

 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",

Insertion in Cargo.lock at line 1173 [25.12201]

[10.46146]

 "opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1178 [25.12201]
∅:D[10.46175] → [2.19866:19884]
```
version = "0.7.1"
```
[10.46175]
[10.46193]
```
version = "0.8.0"
```

Replacement in Cargo.lock at line 1181 [25.12201]

∅:D[10.46275] → [2.19885:20114]

 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",

[10.46275]

[10.46504]

 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",

Insertion in Cargo.lock at line 1184 [25.12201]

[10.46580]

 "opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1189 [25.12201]
∅:D[10.46609] → [2.20115:20133]
```
version = "0.7.3"
```
[10.46609]
[10.46627]
```
version = "0.8.1"
```

Replacement in Cargo.lock at line 1192 [25.12201]

∅:D[10.46709] → [2.20134:20363]

 "block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",

[10.46709]

[10.46938]

 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",

Insertion in Cargo.lock at line 1196 [25.12201]

[10.47011]

 "opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1201 [25.12201]
∅:D[10.47047] → [2.20364:20382]
```
version = "0.1.6"
```
[10.47047]
[10.47065]
```
version = "0.1.7"
```

Replacement in Cargo.lock at line 1204 [25.12201]

∅:D[10.47147] → [2.20383:20530]

 "arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",

[10.47147]

[10.47294]

 "arc-swap 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1215 [25.12201]
∅:D[10.47438] → [2.20531:20549]
```
version = "0.4.1"
```
[10.47438]
[10.47456]
```
version = "0.4.2"
```
Replacement in Cargo.lock at line 1220 [25.12201]
∅:D[10.47552] → [2.20550:20568]
```
version = "0.6.6"
```
[10.47552]
[10.47570]
```
version = "0.6.8"
```

Replacement in Cargo.lock at line 1232 [25.12201]

∅:D[10.47935] → [2.20569:20722]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",

[10.47935]

[10.48088]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1244 [25.12201]
∅:D[10.48316] → [2.20723:20741]
```
version = "0.1.2"
```
[10.48316]
[10.48334]
```
version = "0.1.3"
```

Replacement in Cargo.lock at line 1254 [25.12201]

∅:D[10.48700] → [2.20742:20820]

 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",

[10.48700]

[10.48778]

 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1256 [25.12201]

∅:D[10.48861] → [2.20821:20894]

 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",

[10.48861]

[10.48934]

 "serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1266 [25.12201]

∅:D[10.49252] → [2.20895:21206]

 "phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",

[10.49252]

[10.49563]

 "phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",

Insertion in Cargo.lock at line 1284 [25.12201]

[10.49901]

name = "subtle"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]

Replacement in Cargo.lock at line 1300 [25.12201]
∅:D[10.50268] → [2.21207:21227]
```
version = "0.15.22"
```
[10.50268]
[10.50288]
```
version = "0.15.26"
```

Replacement in Cargo.lock at line 1303 [25.12201]

∅:D[10.50370] → [2.21228:21380]

 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",

[10.50370]

[10.50522]

 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1321 [25.12201]

∅:D[10.50947] → [2.21381:21605]

 "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)",

[10.50947]

[10.51171]

 "proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1333 [25.12201]

∅:D[10.51455] → [2.21606:21830]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",

[10.51455]

[10.51679]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1342 [25.12201]
∅:D[10.51865] → [2.21831:21849]
```
version = "0.4.0"
```
[10.51865]
[10.51883]
```
version = "0.4.1"
```

Replacement in Cargo.lock at line 1347 [25.12201]

∅:D[10.52106] → [2.21850:21922]

 "utf-8 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)",

[10.52106]

[10.52178]

 "utf-8 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1363 [25.12201]

∅:D[10.52519] → [2.21923:22076]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",

[10.52519]

[10.52672]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1386 [25.12201]
∅:D[10.53210] → [2.22077:22096]
```
version = "0.1.40"
```
[10.53210]
[10.53229]
```
version = "0.1.42"
```

Replacement in Cargo.lock at line 1389 [25.12201]

∅:D[10.53311] → [2.22097:22250]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",

[10.53311]

[10.53464]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1396 [25.12201]
∅:D[10.53567] → [2.22251:22270]
```
version = "0.1.13"
```
[10.53567]
[10.53586]
```
version = "0.1.14"
```

Replacement in Cargo.lock at line 1402 [25.12201]

∅:D[10.53887] → [2.22271:22346]

 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",

[10.53887]

[10.53962]

 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1405 [25.12201]

∅:D[10.54127] → [2.22347:22818]

 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",

[10.54127]

[10.54598]

 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1413 [25.12201]

∅:D[10.54752] → [2.22819:22895]

 "tokio-uds 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",

[10.54752]

[10.54828]

 "tokio-uds 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1431 [25.12201]

∅:D[10.55308] → [2.22896:22972]

 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",

[10.55308]

[10.55384]

 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1440 [25.12201]

∅:D[10.55604] → [2.22973:23054]

 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",

[10.55604]

[10.55685]

 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1445 [25.12201]
∅:D[10.55724] → [2.23055:23073]
```
version = "0.1.5"
```
[10.55724]
[10.55742]
```
version = "0.1.6"
```

Insertion in Cargo.lock at line 1448 [25.12201]

[10.55824]

 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1454 [25.12201]
∅:D[10.55932] → [2.23074:23092]
```
version = "0.1.4"
```
[10.55932]
[10.55950]
```
version = "0.1.5"
```

Replacement in Cargo.lock at line 1458 [25.12201]

∅:D[10.56107] → [2.23093:23252]

 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",

[10.56107]

[10.56266]

 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1464 [25.12201]
∅:D[10.56299] → [2.23253:23272]
```
version = "0.1.10"
```
[10.56299]
[10.56318]
```
version = "0.1.11"
```
Replacement in Cargo.lock at line 1474 [25.12201]
∅:D[10.56656] → [2.23273:23291]
```
version = "0.1.7"
```
[10.56656]
[10.56674]
```
version = "0.1.8"
```

Replacement in Cargo.lock at line 1477 [25.12201]

∅:D[10.56756] → [2.23292:23374]

 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",

[10.56756]

[10.56838]

 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1482 [25.12201]

∅:D[10.57132] → [2.23375:23756]

 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",

[10.57132]

[10.57513]

 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1495 [25.12201]

∅:D[10.57725] → [2.23757:23829]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",

[10.57725]

[10.57797]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1498 [25.12201]

∅:D[10.57942] → [2.23830:24145]

 "signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

[10.57942]

[10.58257]

 "signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1507 [25.12201]
∅:D[10.58364] → [2.24146:24164]
```
version = "0.1.2"
```
[10.58364]
[10.58382]
```
version = "0.1.3"
```

Replacement in Cargo.lock at line 1514 [25.12201]

∅:D[10.58755] → [2.24165:24321]

 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

[10.58755]

[10.58911]

 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1520 [25.12201]
∅:D[10.58952] → [2.24322:24340]
```
version = "0.1.9"
```
[10.58952]
[10.58970]
```
version = "0.1.10"
```

Replacement in Cargo.lock at line 1523 [25.12201]

∅:D[10.59052] → [2.24341:24505]

 "crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",

[10.59052]

[10.59216]

 "crossbeam-channel 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1528 [25.12201]

∅:D[10.59361] → [2.24506:24733]

 "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",

[10.59361]

[10.59588]

 "num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1538 [25.12201]

∅:D[10.59724] → [2.24734:24816]

 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",

[10.59724]

[10.59806]

 "crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1540 [25.12201]

∅:D[10.59881] → [2.24817:24969]

 "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",

[10.59881]

[10.60033]

 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1546 [25.12201]
∅:D[10.60067] → [2.24970:24988]
```
version = "0.2.0"
```
[10.60067]
[10.60085]
```
version = "0.2.1"
```

Replacement in Cargo.lock at line 1551 [25.12201]

∅:D[10.60319] → [2.24989:25065]

 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",

[10.60319]

[10.60395]

 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1564 [25.12201]

∅:D[10.60896] → [2.25066:25222]

 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

[10.60896]

[10.61052]

 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1570 [25.12201]
∅:D[10.61086] → [2.25223:25241]
```
version = "0.2.4"
```
[10.61086]
[10.61104]
```
version = "0.2.5"
```

Replacement in Cargo.lock at line 1576 [25.12201]

∅:D[10.61406] → [2.25242:25314]

 "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",

[10.61406]

[10.61478]

 "libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1581 [25.12201]

∅:D[10.61771] → [2.25315:25471]

 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

[10.61771]

[10.61927]

 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1587 [25.12201]
∅:D[10.61962] → [2.25472:25490]
```
version = "0.2.0"
```
[10.61962]
[10.61980]
```
version = "0.2.3"
```

Deletion in Cargo.lock at line 1594 [25.12201]

∅:D[10.62360] → [2.25491:25635]

 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1595 [25.12201]

∅:D[10.62581] → [2.25636:25857]

 "quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",

[10.62581]

[10.62802]

 "quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "sasl 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1599 [25.12201]

∅:D[10.62880] → [2.25858:26252]

 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",

[10.62880]

[10.63274]

 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tls 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-resolver 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1604 [25.12201]

∅:D[10.63350] → [2.26253:26333]

 "xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)",

[10.63350]

[10.63430]

 "xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1612 [25.12201]

∅:D[10.63560] → [2.26334:26407]

 "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",

[10.63560]

[10.63633]

 "serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1617 [25.12201]
∅:D[10.63673] → [2.26408:26426]
```
version = "0.4.3"
```
[10.63673]
[10.63691]
```
version = "0.6.2"
```

Replacement in Cargo.lock at line 1620 [25.12201]

∅:D[10.63773] → [2.26427:26582]

 "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",

[10.63773]

[10.63928]

 "byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1626 [25.12201]

∅:D[10.64222] → [2.26583:26729]

 "rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",

[10.64222]

[10.64368]

 "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1629 [25.12201]

∅:D[10.64442] → [2.26730:27043]

 "tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",

[10.64442]

[10.64755]

 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1640 [25.12201]
∅:D[10.65022] → [2.27044:27062]
```
version = "0.9.1"
```
[10.65022]
[10.65040]
```
version = "0.10.2"
```

Replacement in Cargo.lock at line 1644 [25.12201]

∅:D[10.65195] → [2.27063:27142]

 "error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",

[10.65195]

[10.65274]

 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1650 [25.12201]

∅:D[10.65648] → [2.27143:27451]

 "resolv-conf 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",

[10.65648]

[10.65956]

 "resolv-conf 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1663 [25.12201]
∅:D[10.66103] → [2.27452:27470]
```
version = "0.2.2"
```
[10.66103]
[10.66121]
```
version = "0.3.2"
```

Insertion in Cargo.lock at line 1665 [25.12201]

[10.66186]

dependencies = [
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
]

Replacement in Cargo.lock at line 1727 [25.12201]
∅:D[10.67696] → [2.27471:27489]
```
version = "0.7.4"
```
[10.67696]
[10.67714]
```
version = "0.7.5"
```

Deletion in Cargo.lock at line 1743 [25.12201]

∅:D[10.68055] → [2.27490:27609]

source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "version_check"
version = "0.1.5"

Replacement in Cargo.lock at line 1843 [25.12201]

∅:D[10.71090] → [2.27610:27760]

 "markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",

[10.71090]

[10.71240]

 "markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1849 [25.12201]
∅:D[10.71277] → [2.27761:27780]
```
version = "0.11.1"
```
[10.71277]
[10.71296]
```
version = "0.12.2"
```

Replacement in Cargo.lock at line 1852 [25.12201]

∅:D[10.71378] → [2.27781:27927]

 "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",

[10.71378]

[10.71524]

 "base64 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1855 [25.12201]

∅:D[10.71597] → [2.27928:28434]

 "digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",

[10.71597]

[10.72103]

 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "jid 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",

Insertion in Cargo.lock at line 1865 [25.12201]

[10.72117]

"checksum MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "eaf9f0d0b1cc33a4d2aee14fb4b2eac03462ef4db29c8ac4057327d8a71ad86f"

Replacement in Cargo.lock at line 1868 [25.12201]

∅:D[10.72425] → [2.28435:28888]

"checksum arc-swap 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "5c5ed110e2537bdd3f5b9091707a8a5556a72ac49bbd7302ae0b28fdccb3246c"
"checksum arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0d382e583f07208808f6b1249e60848879ba3543f57c32277bf52d69c2f0f0ee"
"checksum arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "f405cc4c21cd8b784f6c8fc2adf9bc00f59558f0049b5ec21517f875963040cc"

[10.72425]

[10.72878]

"checksum arc-swap 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1025aeae2b664ca0ea726a89d574fe8f4e77dd712d443236ad1de00379450cf6"
"checksum arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "92c7fb76bc8826a8b33b4ee5bb07a247a81e76764ab4d55e8f73e3a4d8808c71"

Replacement in Cargo.lock at line 1871 [25.12201]

∅:D[10.73026] → [2.28889:29499]

"checksum backtrace 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "346d7644f0b5f9bc73082d3b2236b69a05fd35cce0cfa3724e184e6a5c9e2a2f"
"checksum backtrace 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "89a47830402e9981c5c41223151efcced65a0510c13097c769cede7efb34782a"
"checksum backtrace-sys 0.1.24 (registry+https://github.com/rust-lang/crates.io-index)" = "c66d56ac8dabd07f6aacdaf633f4b8262f5b3601a810a0dcddffd5c22c69daa0"
"checksum base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)" = "489d6c0ed21b11d038c31b6ceccca973e65d73ba3bd8ecb9a2babf5546164643"

[10.73026]

[10.73636]

"checksum autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a6d640bee2da49f60a4068a7fae53acde8982514ab7bae8b8cea9e88cbcfd799"
"checksum backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)" = "b5b493b66e03090ebc4343eb02f94ff944e0cbc9ac6571491d170ba026741eb5"
"checksum backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)" = "797c830ac25ccc92a7f8a7b9862bde440715531514594a6154e3d4a54dd769b6"
"checksum base64 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "621fc7ecb8008f86d7fb9b95356cd692ce9514b80a86d85b397f32a22da7b9e2"

Replacement in Cargo.lock at line 1876 [25.12201]

∅:D[10.73787] → [2.29500:30109]

"checksum blake2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73b77e29dbd0115e43938be2d5128ecf81c0353e00acaa65339a1242586951d9"
"checksum block-buffer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a076c298b9ecdb530ed9d967e74a6027d6a7478924520acddcddc24c1c8ab3ab"
"checksum byte-tools 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "560c32574a12a89ecd91f5e742165893f86e3ab98d21f8ea548658eb9eef5f40"
"checksum byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "94f88df23a25417badc922ab0f5716cc1330e87f71ddd9203b3a3ccd9cedf75d"

[10.73787]

[10.74396]

"checksum blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "91721a6330935673395a0607df4d49a9cb90ae12d259f1b3e0a3f6e1d486872e"
"checksum block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49665c62e0e700857531fa5d3763e91b539ff1abeebd56808d378b495870d60d"
"checksum block-padding 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4fc4358306e344bf9775d0197fd00d2603e5afb0771bb353538630f022068ea3"
"checksum byte-tools 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "980479e6fde23246dfb54d47580d66b4e99202e7579c5eaa9fe10ecb5ebd2182"
"checksum byteorder 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "60f0b0d4c0a382d2734228fd12b5a6b5dac185c60e938026fd31b265b94f9bd2"

Replacement in Cargo.lock at line 1883 [25.12201]

∅:D[10.74692] → [2.30110:30256]

"checksum cc 1.0.25 (registry+https://github.com/rust-lang/crates.io-index)" = "f159dfd43363c4d08055a07703eb7a3406b0dac4d0584d96965a3262db3c9d16"

[10.74692]

[10.74838]

"checksum cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4a8b715cb4597106ea87c7c84b2f1d452c7492033765df7f32651e66fcf749"

Deletion in Cargo.lock at line 1888 [25.12201]

∅:D[10.75435] → [2.30257:30416]

"checksum constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8ff012e225ce166d4422e0e78419d901719760f62ae2b7969ca6b564d1b54a9e"

Replacement in Cargo.lock at line 1890 [25.12201]

∅:D[10.75914] → [2.30417:31198]

"checksum crossbeam-deque 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4fe1b6f945f824c7a25afe44f62e25d714c0cc523f8e99d8db5cd1026e1269d3"
"checksum crossbeam-epoch 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2449aaa4ec7ef96e5fb24db16024b935df718e9ae1cec0a1e68feeca2efca7b8"
"checksum crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c55913cc2799171a550e307918c0a360e8c16004820291bf3b638969b4a01816"
"checksum crypto-mac 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "0999b4ff4d3446d4ddb19a63e9e00c1876e75cd7000d20e57a693b4b3f08d958"
"checksum dbghelp-sys 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "97590ba53bcb8ac28279161ca943a924d1fd4a8fb3fa63302591647c4fc5b850"

[10.75914]

[10.76695]

"checksum crossbeam-channel 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "137bc235f622ffaa0428e3854e24acb53291fc0b3ff6fb2cb75a8be6fb02f06b"
"checksum crossbeam-deque 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "05e44b8cf3e1a625844d1750e1f7820da46044ff6d28f4d43e455ba3e5bb2c13"
"checksum crossbeam-epoch 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f10a4f8f409aaac4b16a5474fb233624238fcdeefb9ba50d5ea059aab63ba31c"
"checksum crossbeam-utils 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "41ee4864f4797060e52044376f7d107429ce1fb43460021b126424b7180ee21a"
"checksum crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4434400df11d95d556bac068ddfedd482915eb18fe8bea89bc80b6e4b1c179e5"

Replacement in Cargo.lock at line 1896 [25.12201]

∅:D[10.76850] → [2.31199:31503]

"checksum digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)" = "03b072242a8cbaf9c145665af9d250c59af3b958f83ed6824e13533cf76d5b90"
"checksum encoding_rs 0.8.12 (registry+https://github.com/rust-lang/crates.io-index)" = "ca20350a7cb5aab5b9034731123d6d412caf3e92d4985e739e411ba0955fd0eb"

[10.76850]

[10.77154]

"checksum digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "05f47366984d3ad862010e22c7ce81a7dbcaebbdfb37241a620f8b6596ee135c"
"checksum encoding_rs 0.8.14 (registry+https://github.com/rust-lang/crates.io-index)" = "a69d152eaa438a291636c1971b0a370212165ca8a75759eb66818c5ce9b538f7"

Deletion in Cargo.lock at line 1899 [25.12201]

∅:D[10.77307] → [2.31504:31659]

"checksum error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faa976b4fd2e4c2b2f3f486874b19e61944d3de3de8b61c9fcf835d583871bcc"

Replacement in Cargo.lock at line 1900 [25.12201]

∅:D[10.77616] → [2.31660:31967]

"checksum failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6dd377bcc1b1b7ce911967e3ec24fa19c3224394ec05b54aa7b083d498341ac7"
"checksum failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "64c2d913fe8ed3b6c6518eedf4538255b989945c14c2a7d5cbff62a5e2120596"

[10.77616]

[10.77923]

"checksum failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "795bd83d3abeb9220f257e597aa0080a508b27533824adf336529648f6abf7e2"
"checksum failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "ea1063915fd7ef4309e222a5a07cf9c319fb9c7836b1f89b85458672dbb127e1"

Replacement in Cargo.lock at line 1911 [25.12201]

∅:D[10.79314] → [2.31968:32270]

"checksum generic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ef25c5683767570c2bbd7deba372926a55eaae9982d7726ee2a1050239d45b9d"
"checksum h2 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "1ac030ae20dee464c5d0f36544d8b914a6bc606da44a57e052d2b0f5dae129e0"

[10.79314]

[10.79616]

"checksum generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3c0f28c2f5bfb5960175af447a2da7c18900693738343dc896ffbcabd9839592"
"checksum h2 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "30e0b8e55b4d7ffedade2b9605851f8e85f5010663e7ad170ef3c0f0681bc43f"
"checksum hmac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f127a908633569f208325f86f71255d3363c79721d7f9fe31cd5569908819771"

Replacement in Cargo.lock at line 1918 [25.12201]

∅:D[10.80218] → [2.32271:32421]

"checksum hyper 0.12.17 (registry+https://github.com/rust-lang/crates.io-index)" = "c49a75385d35ff5e9202755f09beb0b878a05c4c363fcc52b23eeb5dcb6782cc"

[10.80218]

[10.80368]

"checksum hyper 0.12.21 (registry+https://github.com/rust-lang/crates.io-index)" = "6d6b1a3d01ac8035b8d2d94e0e5254eab82746f09046baed763751b00253232b"

Replacement in Cargo.lock at line 1924 [25.12201]

∅:D[10.81112] → [2.32422:32568]

"checksum jid 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6c4cee633b7ce95e71202ecb99e632d15ad468de7753e616a924c93842f1a3d0"

[10.81112]

[10.81258]

"checksum jid 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "24e8a3f2ab860aa08074136e3144a2425e678d8823206e5adcc6145dc136503a"

Replacement in Cargo.lock at line 1929 [25.12201]

∅:D[10.81867] → [2.32569:32717]

"checksum libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)" = "10923947f84a519a45c8fefb7dd1b3e8c08747993381adee176d7a82b4195311"

[10.81867]

[10.82015]

"checksum libc 0.2.47 (registry+https://github.com/rust-lang/crates.io-index)" = "48450664a984b25d5b479554c29cc04e3150c97aa4c01da5604a2d4ed9151476"

Replacement in Cargo.lock at line 1935 [25.12201]

∅:D[10.82768] → [2.32718:32872]

"checksum markup5ever 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a87c4100d614080c8ab43334fb028ebe387f273fb61ed4ff0eae9189b94b6be8"

[10.82768]

[10.82922]

"checksum markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "897636f9850c3eef4905a5540683ed53dc9393860f0846cab2c2ddf9939862ff"

Replacement in Cargo.lock at line 1937 [25.12201]

∅:D[10.83072] → [2.32873:33022]

"checksum memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0a3eb002f0535929f1199681417029ebea04aadc0c7a4224b46be99c7f5d6a16"

[10.83072]

[10.83221]

"checksum memchr 2.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e1dd4eaac298c32ce07eb6ed9242eda7d82955b9170b7d6db59b2e02cc63fcb8"

Replacement in Cargo.lock at line 1939 [25.12201]

∅:D[10.83373] → [2.33023:33173]

"checksum minidom 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c0a5296bf9d0ac9e4a6e4cb844e3ee84bf33f841c7b3ae2cc87f05ceb81b50ae"

[10.83373]

[10.83523]

"checksum minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "275024eea6c6ff4ace22f2750843831183785288eec1cff91a4e6b8898cf94f9"

Replacement in Cargo.lock at line 1949 [25.12201]

∅:D[10.84890] → [2.33174:33477]

"checksum num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c51a3322e4bca9d212ad9a158a02abc6934d005490c054a2778df73a70aa0a30"
"checksum openssl 0.10.15 (registry+https://github.com/rust-lang/crates.io-index)" = "5e1309181cdcbdb51bc3b6bedb33dfac2a83b3d585033d3f6d9e22e8c1928613"

[10.84890]

[10.85193]

"checksum num_cpus 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5a69d464bdc213aaaff628444e99578ede64e9c854025aa43b9796530afa9238"
"checksum opaque-debug 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "51ecbcb821e1bd256d456fe858aaa7f380b63863eab2eb86eee1bd9f33dd6682"
"checksum openssl 0.10.16 (registry+https://github.com/rust-lang/crates.io-index)" = "ec7bd7ca4cce6dbdc77e7c1230682740d307d1218a87fb0349a571272be749f9"

Replacement in Cargo.lock at line 1953 [25.12201]

∅:D[10.85349] → [2.33478:33633]

"checksum openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)" = "278c1ad40a89aa1e741a1eed089a2f60b18fab8089c3139b542140fc7d674106"

[10.85349]

[10.85504]

"checksum openssl-sys 0.9.40 (registry+https://github.com/rust-lang/crates.io-index)" = "1bb974e77de925ef426b6bc82fce15fd45bdcbeb5728bffcfc7cdeeb7ce1c2d6"

Replacement in Cargo.lock at line 1955 [25.12201]

∅:D[10.85657] → [2.33634:33947]

"checksum parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "f0802bff09003b291ba756dc7e79313e51cc31667e94afbe847def490424cde5"
"checksum parking_lot_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ad7f7e6ebdc79edff6fdcb87a55b620174f7a989e3eb31b65231f4af57f00b8c"

[10.85657]

[10.85970]

"checksum parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ab41b4aed082705d1056416ae4468b6ea99d52599ecf3169b00088d43113e337"
"checksum parking_lot_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "94c8c7923936b28d546dfd14d4472eaf34c99b14e1c973a32b3e6d4eb04298c9"
"checksum pbkdf2 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "006c038a43a45995a9670da19e67600114740e8511d4333bf97a56e66a7542d9"

Replacement in Cargo.lock at line 1959 [25.12201]

∅:D[10.86129] → [2.33948:34561]

"checksum phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "cec29da322b242f4c3098852c77a0ca261c9c01b806cae85a5572a1eb94db9a6"
"checksum phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "7d187f00cd98d5afbcd8898f6cf181743a449162aeb329dcd2f3849009e605ad"
"checksum phf_generator 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "03dc191feb9b08b0dc1330d6549b795b9d81aec19efe6b4a45aec8d4caee0c4b"
"checksum phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "b539898d22d4273ded07f64a05737649dc69095d92cb87c7097ec68e3f150b93"

[10.86129]

[10.86742]

"checksum phf 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)" = "b3da44b85f8e8dfaec21adae67f95d93244b2ecf6ad2a692320598dcc8e6dd18"
"checksum phf_codegen 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)" = "b03e85129e324ad4166b06b2c7491ae27fe3ec353af72e72cd1654c7225d517e"
"checksum phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)" = "09364cc93c159b8b06b1f4dd8a4398984503483891b0c26b867cf431fb132662"
"checksum phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)" = "234f71a15de2288bcb7e3b6515828d22af7ec8598ee6d24c3b526fa0a80b67a0"

Replacement in Cargo.lock at line 1965 [25.12201]

∅:D[10.87055] → [2.34562:34717]

"checksum proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)" = "77619697826f31a02ae974457af0b29b723e5619e113e9397b8b82c6bd253f09"

[10.87055]

[10.87210]

"checksum proc-macro2 0.4.26 (registry+https://github.com/rust-lang/crates.io-index)" = "38fddd23d98b2144d197c0eca5705632d4fe2667d14a6be5df8934f8d74f1978"

Replacement in Cargo.lock at line 1967 [25.12201]

∅:D[10.87364] → [2.34718:34871]

"checksum quick-xml 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1d8065cbb01701c11cc195cde85cbf39d1c6a80705b67a157ebb3042e0e5777f"

[10.87364]

[10.87517]

"checksum quick-xml 0.13.2 (registry+https://github.com/rust-lang/crates.io-index)" = "98d8d2d671bd29c6122a98b45ce3106391e89ba378f731274de677f1eff06e5f"

Replacement in Cargo.lock at line 1969 [25.12201]

∅:D[10.87666] → [2.34872:35168]

"checksum quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "53fa22a1994bd0f9372d7a816207d8a2677ad0325b073f5c5332760f0fb62b5c"
"checksum rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8356f47b32624fef5b3301c1be97e5944ecdd595409cc5da11d05f211db6cfbd"

[10.87666]

[10.87962]

"checksum quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)" = "cdd8e04bd9c52e0342b406469d494fcb033be4bdbe5c606016defbb1681411e1"

Replacement in Cargo.lock at line 1971 [25.12201]

∅:D[10.88109] → [2.35169:35470]

"checksum rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ae9d223d52ae411a33cf7e54ec6034ec165df296ccd23533d671a28252b6f66a"
"checksum rand_chacha 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "771b009e3a508cb67e8823dda454aaa5368c7bc1c16829fb77d3e980440dd34a"

[10.88109]

[10.88410]

"checksum rand 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "3906503e80ac6cbcacb2c2973fa8e473f24d7e2747c8c92bb230c2441cad96b5"
"checksum rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "556d3a1ca6600bfcbab7c7c91ccb085ac7fbbcd70e008a98742e7847f4f7bcef"

Insertion in Cargo.lock at line 1977 [25.12201]

[10.89017]

"checksum rand_os 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f46fbd5550acf75b0c2730f5dd1873751daf9beb8f11b44027778fae50d7feca"

Replacement in Cargo.lock at line 1979 [25.12201]

∅:D[10.89168] → [2.35471:35784]

"checksum rand_xorshift 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "effa3fcaa47e18db002bdde6060944b6d2f9cfd8db471c30e873448ad9187be3"
"checksum redox_syscall 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "679da7508e9a6390aeaf7fbd02a800fdc64b73fe2204dd2c8ae66d22d9d5ad5d"

[10.89168]

[10.89481]

"checksum rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cbf7e9e623549b0e21f6e97cf8ecf247c1a8fd2e8a992ae265314300b2455d5c"
"checksum rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
"checksum redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)" = "423e376fffca3dfa06c9e9790a9ccd282fafb3cc6e6397d01dbf64f9bacc6b85"

Replacement in Cargo.lock at line 1983 [25.12201]

∅:D[10.89637] → [2.35785:36088]

"checksum regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ee84f70c8c08744ea9641a731c7fadb475bf2ecc52d7f627feb833e0b3990467"
"checksum regex-syntax 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "fbc557aac2b708fe84121caf261346cc2eed71978024337e42eb46b8a252ac6e"

[10.89637]

[10.89940]

"checksum regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "37e7cbbd370869ce2e8dff25c7018702d10b21a20ef7135316f8daecd6c25b7f"
"checksum regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4e47a2ed29da7a9e1960e1639e7a982e6edc6d49be308a3b02daf511504a16d1"

Replacement in Cargo.lock at line 1986 [25.12201]

∅:D[10.90097] → [2.36089:36400]

"checksum resolv-conf 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c62bd95a41841efdf7fca2ae9951e64a8d8eae7e5da196d8ce489a2241491a92"
"checksum rustc-demangle 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "bcfe5b13211b4d78e5c2cadfebd7769197d95c639c35a50057eb4c05de811395"

[10.90097]

[10.90408]

"checksum resolv-conf 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b263b4aa1b5de9ffc0054a2386f96992058bb6870aab516f8cdeb8a667d56dcb"
"checksum rustc-demangle 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "adacaae16d02b6ec37fdc7acfcddf365978de76d1983d3ee22afc260e1ca9619"

Replacement in Cargo.lock at line 1990 [25.12201]

∅:D[10.90710] → [2.36401:36698]

"checksum safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8dca453248a96cb0749e36ccdfe2b0b4e54a61bfef89fb97ec621eb8e0a93dd9"
"checksum sasl 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4dbda5436dcd059da44fbf84b87a7164c5e3cad354efd0630c1f2be3c51c8859"

[10.90710]

[10.91007]

"checksum sasl 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e457758c85b736bbad56dc099406cd2a9c19554cf81880dba7a51d092929e600"

Replacement in Cargo.lock at line 1993 [25.12201]

∅:D[10.91312] → [2.36699:37025]

"checksum security-framework 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "697d3f3c23a618272ead9e1fb259c1411102b31c6af8b93f1d64cca9c3b0e8e0"
"checksum security-framework-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ab01dfbe5756785b5b4d46e0289e5a18071dfa9a7c2b24213ea00b9ef9b665bf"

[10.91312]

[10.91638]

"checksum security-framework 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "bfab8dda0e7a327c696d893df9ffa19cadc4bd195797997f5223cf5831beaf05"
"checksum security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3d6696852716b589dff9e886ff83778bb635150168e83afa8ac6b8a78cb82abc"

Replacement in Cargo.lock at line 1997 [25.12201]

∅:D[10.91943] → [2.37026:38081]

"checksum serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "15c141fc7027dd265a47c090bf864cf62b42c4d228bbcf4e51a0c9e2b0d3f7ef"
"checksum serde_derive 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)" = "225de307c6302bec3898c51ca302fc94a7a1697ef0845fcee6448f33c032249c"
"checksum serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)" = "c37ccd6be3ed1fdf419ee848f7c758eb31b054d7cd3ae3600e3bae0adf569811"
"checksum sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "51b9d1f3b5de8a167ab06834a7c883bd197f2191e1dda1a22d9ccfeedbf9aded"
"checksum sha2 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9eb6be24e4c23a84d7184280d2722f7f2731fcdd4a9d886efbfe4413e4847ea0"
"checksum sha3 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b64dcef59ed4290b9fb562b53df07f564690d6539e8ecdd4728cf392477530bc"
"checksum signal-hook 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "8941ae94fa73d0f73b422774b3a40a7195cecd88d1c090f4b37ade7dc795ab66"

[10.91943]

[10.92998]

"checksum serde 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)" = "534b8b91a95e0f71bca3ed5824752d558da048d4248c91af873b63bd60519752"
"checksum serde_derive 1.0.85 (registry+https://github.com/rust-lang/crates.io-index)" = "a915306b0f1ac5607797697148c223bedeaa36bcc2e28a01441cd638cc6567b4"
"checksum serde_json 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)" = "574378d957d6dcdf1bbb5d562a15cbd5e644159432f84634b94e485267abbcc7"
"checksum sha-1 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "23962131a91661d643c98940b20fcaffe62d776a823247be80a48fcb8b6fce68"
"checksum sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7b4d8bfd0e469f417657573d8451fb33d16cfe0989359b93baf3a1ffc639543d"
"checksum sha3 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "34a5e54083ce2b934bf059fdf38e7330a154177e029ab6c4e18638f2f624053a"
"checksum signal-hook 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1f272d1b7586bec132ed427f532dd418d8beca1ca7f2caf7df35569b1415a4b4"

Replacement in Cargo.lock at line 2005 [25.12201]

∅:D[10.93150] → [2.38082:38380]

"checksum slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5f9776d6b986f77b35c6cf846c11ad986ff128fe0b2b63a3628e3755e8d3102d"
"checksum smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "622df2d454c29a4d89b30dc3b27b42d7d90d6b9e587dbf8f67652eb7514da484"

[10.93150]

[10.93448]

"checksum slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
"checksum smallvec 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "88aea073965ab29f6edb5493faf96ad662fb18aa9eeb186a3b7057951605ed15"

Replacement in Cargo.lock at line 2009 [25.12201]

∅:D[10.93759] → [2.38381:38530]

"checksum string 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "98998cced76115b1da46f63388b909d118a37ae0be0f82ad35773d4a4bc9d18d"

[10.93759]

[10.93908]

"checksum string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b639411d0b9c738748b5397d5ceba08e648f4f1992231aa859af1a017f31f60b"

Insertion in Cargo.lock at line 2014 [25.12201]

[10.94537]

"checksum subtle 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2d67a5a62ba6e01cb2192ff309324cb4875d0c451d55fe2319433abe7a05a8ee"

Replacement in Cargo.lock at line 2016 [25.12201]

∅:D[10.94685] → [2.38531:38679]

"checksum syn 0.15.22 (registry+https://github.com/rust-lang/crates.io-index)" = "ae8b29eb5210bc5cf63ed6149cbf9adfc82ac0be023d8735c176ee74a2db4da7"

[10.94685]

[10.94833]

"checksum syn 0.15.26 (registry+https://github.com/rust-lang/crates.io-index)" = "f92e629aa1d9c827b2bb8297046c1ccffc57c99b947a680d3ccff1f136a3bee9"

Replacement in Cargo.lock at line 2020 [25.12201]

∅:D[10.95289] → [2.38680:38830]

"checksum tendril 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9de21546595a0873061940d994bbbc5c35f024ae4fd61ec5c5b159115684f508"

[10.95289]

[10.95439]

"checksum tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "707feda9f2582d5d680d733e38755547a3e8fb471e7ba11452ecfd9ce93a5d3b"

Replacement in Cargo.lock at line 2025 [25.12201]

∅:D[10.96048] → [2.38831:39128]

"checksum time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "d825be0eb33fda1a7e68012d51e9c7f451dc1a69391e7fdc197060bb8c56667b"
"checksum tokio 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "a7817d4c98cc5be21360b3b37d6036fe9b7aefa5b7a201b7b16ff33423822f7d"

[10.96048]

[10.96345]

"checksum time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)" = "db8dcfca086c1143c9270ac42a2bbd8a7ee477b78ac8e45b19abfb0cbede4b6f"
"checksum tokio 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "4790d0be6f4ba6ae4f48190efa2ed7780c9e3567796abdb285003cf39840d9c5"

Replacement in Cargo.lock at line 2030 [25.12201]

∅:D[10.96818] → [2.39129:39745]

"checksum tokio-executor 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "c117b6cf86bb730aab4834f10df96e4dd586eff2c3c27d3781348da49e255bde"
"checksum tokio-fs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "60ae25f6b17d25116d2cba342083abe5255d3c2c79cb21ea11aa049c53bf7c75"
"checksum tokio-io 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "7392fe0a70d5ce0c882c4778116c519bd5dbaa8a7c3ae3d04578b3afafdcda21"
"checksum tokio-reactor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "502b625acb4ee13cbb3b90b8ca80e0addd263ddacf6931666ef751e610b07fb5"

[10.96818]

[10.97434]

"checksum tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "30c6dbf2d1ad1de300b393910e8a3aa272b724a400b6531da03eed99e329fbf0"
"checksum tokio-fs 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0e9cbbc8a3698b7ab652340f46633364f9eaa928ddaaee79d8b8f356dd79a09d"
"checksum tokio-io 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "b53aeb9d3f5ccf2ebb29e19788f96987fa1355f8fe45ea193928eaaaf3ae820f"
"checksum tokio-reactor 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "afbcdb0f0d2a1e4c440af82d7bbf0bf91a8a8c0575bcd20c05d15be7e9d3a02f"

Replacement in Cargo.lock at line 2035 [25.12201]

∅:D[10.97589] → [2.39746:40057]

"checksum tokio-tcp 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7ad235e9dadd126b2d47f6736f65aa1fdcd6420e66ca63f44177bc78df89f912"
"checksum tokio-threadpool 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "56c5556262383032878afad66943926a1d1f0967f17e94bd7764ceceb3b70e7f"

[10.97589]

[10.97900]

"checksum tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1d14b10654be682ac43efee27401d792507e30fd8d26389e1da3b185de2e4119"
"checksum tokio-threadpool 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "17465013014410310f9f61fa10bf4724803c149ea1d51efece131c38efca93aa"

Replacement in Cargo.lock at line 2038 [25.12201]

∅:D[10.98054] → [2.40058:40210]

"checksum tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e53fdbf3156f588be1676022fe794232b24922d426e8c14f4e46891c1e31c440"

[10.98054]

[10.98206]

"checksum tokio-tls 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "354b8cd83825b3c20217a9dc174d6a0c67441a2fae5c41bcb1ea6679f6ae0f7c"

Replacement in Cargo.lock at line 2040 [25.12201]

∅:D[10.98358] → [2.40211:40516]

"checksum tokio-uds 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "99ce87382f6c1a24b513a72c048b2c8efe66cb5161c9061d00bee510f08dc168"
"checksum tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c27385c4781afc851c61ac66d79463c511bf073d3a5d71b8bfd13a816e475989"

[10.98358]

[10.98663]

"checksum tokio-uds 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "037ffc3ba0e12a0ab4aca92e5234e0dedeb48fddf6ccd260f1f150a36a9f2445"
"checksum tokio-xmpp 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "838f8a47654f45fd3618288ebda6085578f783ae087d82f12c09e04f7513a690"

Replacement in Cargo.lock at line 2043 [25.12201]

∅:D[10.98811] → [2.40517:40836]

"checksum trust-dns-proto 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f1525ca4e26f5a09d81b79584f19225e7dba5606ae3a416311c2751c5cea60bb"
"checksum trust-dns-resolver 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4a821ad51a29816420b8cac4b026756b81c023630b97eaa4c8090637ee3508bd"

[10.98811]

[10.99130]

"checksum trust-dns-proto 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "30dde452f5d142d5e316a3b32386da95280c98b7e266639f8f3bc6fdf507d279"
"checksum trust-dns-resolver 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)" = "de630f95a192f793436ffae5137e88253cc4142a97d9a8e73c8d804fa85ddf0a"

Replacement in Cargo.lock at line 2046 [25.12201]

∅:D[10.99281] → [2.40837:40988]

"checksum try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "923a7ee3e97dbfe8685261beb4511cc9620a1252405d02693d43169729570111"

[10.99281]

[10.99432]

"checksum try_from 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "283d3b89e1368717881a9d51dad843cc435380d8109c9e47d38780a324698d8b"

Replacement in Cargo.lock at line 2056 [25.12201]

∅:D[10.100817] → [2.40989:41137]

"checksum utf-8 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)" = "bab35f71693630bb1953dce0f2bcd780e7cde025027124a202ac08a45ba25141"

[10.100817]

[10.100965]

"checksum utf-8 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "05e42f7c18b8f902290b009cde6d651262f956c98bc51bca4cd1d511c9cd85c7"

Deletion in Cargo.lock at line 2060 [25.12201]

∅:D[10.101417] → [2.41138:41294]

"checksum version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd"

Replacement in Cargo.lock at line 2074 [25.12201]

∅:D[10.103722] → [2.41295:41451]

"checksum xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2e1e0a279d5af83a1dff442249f8a43214ac120267acfaac494b9d28c0027fea"

[10.103722]

"checksum xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)" = "58b4400e1ae0d246044db5fa7f2e693fdfe9cc6e8eaa72ef2a68c5dc1d3c96de"