o01eg/sendxmppd-rs - Change RRLRZTMR3RQMZCMPIW5DJYAH5A6GXJMJ6ACOM2DPRYXQMQAGMPVAC

Use element processor for iq

Created by O01eg on April 13, 2019

RRLRZTMR3RQMZCMPIW5DJYAH5A6GXJMJ6ACOM2DPRYXQMQAGMPVAC

Dependencies

In channels

main

Change contents

Insertion in src/xmpp/stanzas.rs at line 3 [4.13]

[3.26]

[4.57]

use xmpp_parsers::message::{Body, Message, MessageType};
use xmpp_parsers::ping::Ping;

Replacement in src/xmpp/stanzas.rs at line 6 [4.13]
∅:D[4.141] → [2.0:34]
```
use xmpp_parsers::roster::Roster;
```
[4.141]
[4.141]
```
use xmpp_parsers::roster::{Item, Roster};
```

Replacement in src/xmpp/stanzas.rs at line 18 [4.13]

∅:D[3.196] → [2.35:196]

    let mut get_roster = Iq::from_get(Roster {
        ver: None,
        items: vec![],
    });
    get_roster.id = Some(id.to_string());
    get_roster.into()

[3.196]

[3.357]

    Iq::from_get(
        id,
        Roster {
            items: vec![],
            ver: None,
        },
    )
    .into()
}
pub fn make_add_roster(id: &str, jid: xmpp_parsers::Jid) -> Element {
    Iq::from_set(
        id,
        Roster {
            items: vec![Item {
                jid,
                name: None,
                subscription: xmpp_parsers::roster::Subscription::None,
                ask: xmpp_parsers::roster::Ask::None,
                groups: vec![],
            }],
            ver: None,
        },
    )
    .into()
}
pub fn make_ask_subscribe(jid: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Subscribe);
    presence.to = Some(jid);
    presence.into()
}
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()
}
pub fn make_muc_presence(id: &str, from: xmpp_parsers::Jid, to: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::None);
    presence.from = Some(from);
    presence.to = Some(to);
    presence.id = Some(id.to_string());
    presence.add_payload(xmpp_parsers::muc::Muc::new());
    presence.into()
}
pub fn make_muc_message(to: xmpp_parsers::Jid, text: String) -> Element {
    let mut message = Message::new(Some(to.into_bare_jid()));
    message.bodies.insert(String::new(), Body(text));
    message.type_ = MessageType::Groupchat;
    message.into()

Insertion in src/xmpp/stanzas.rs at line 73 [4.13]

[3.359]


pub fn make_muc_presence_leave(from: xmpp_parsers::Jid, to: xmpp_parsers::Jid) -> Element {
    let mut presence = Presence::new(PresenceType::Unavailable);
    presence.from = Some(from);
    presence.to = Some(to);
    presence.into()
}
pub fn make_ping(id: &str, from: xmpp_parsers::Jid) -> Element {
    let mut ping = Iq::from_get(id, Ping);
    ping.to = Some(from.clone().into_domain_jid());
    ping.from = Some(from);
    ping.into()
}
pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Element {
    let mut pong = Iq::from_result(id, None as Option<Roster>);
    pong.from = Some(from);
    pong.to = to;
    pong.into()
}

Replacement in src/xmpp/mod.rs at line 4 [5.17]
∅:D[5.164] → [2.197:230]
```
use tokio_xmpp::{Client, Event};
```
[5.164]
[5.197]
```
use tokio_xmpp::{Client, Event, Packet};
```
Replacement in src/xmpp/mod.rs at line 8 [5.17]
∅:D[3.1193] → [2.231:262]
```
use std::collections::HashMap;
```
[3.1193]
[4.420]
```
use std::collections::{HashMap, VecDeque};
```
Deletion in src/xmpp/mod.rs at line 11 [5.17]
∅:D[4.434] → [2.263:296]
```
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
```

Deletion in src/xmpp/mod.rs at line 12 [5.17]

∅:D[2.297] → [2.297:377]

const ID_GET_ROSTER: &str = "id_get_roster0";
================================

Deletion in src/xmpp/mod.rs at line 13 [5.17]
∅:D[2.400] → [2.400:433]
```
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
```

Replacement in src/xmpp/mod.rs at line 16 [5.17]

∅:D[3.1274] → [2.434:490]

    roster: HashMap<jid::Jid, ()>,
    _counter: usize,

[3.1274]

[3.1786]

    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// ids counter
    counter: usize,
    /// map from id of adding item to roster and jid of item
    pending_add_roster_ids: HashMap<String, xmpp_parsers::Jid>,
    /// stanzas to send
    send_queue: VecDeque<minidom::Element>,
    /// outgoing mailbox
    outgoing_mailbox: HashMap<xmpp_parsers::Jid, Vec<String>>,
    /// muc id to muc jid
    mucs: HashMap<String, xmpp_parsers::Jid>,

Replacement in src/xmpp/mod.rs at line 42 [5.17]

∅:D[2.524] → [2.524:611]

    incoming: element_processor::Processor<XmppConnection, (), xmpp_parsers::Element>,

[2.524]

[3.1848]

    incoming: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element>,

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

∅:D[2.679] → [2.679:795]

        let mut incoming =
            element_processor::Processor::new(&|_, e| warn!("Unknown stanza {:#?}", e));

[2.679]

[2.795]

        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {:#?}", e);
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);

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

∅:D[3.2671] → [2.848:900]

                as Box<Future<Item = _, Error = _>>

[3.2671]

[5.944]

                as Box<dyn Future<Item = _, Error = _>>

Replacement in src/xmpp/mod.rs at line 118 [5.17]

∅:D[6.1591] → [2.901:1320]

                            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");

[6.1591]

[5.1476]

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

Replacement in src/xmpp/mod.rs at line 122 [5.17]

∅:D[5.1477] → [2.1321:1473]

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

[5.1477]

[7.1065]

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

Replacement in src/xmpp/mod.rs at line 126 [5.17]

∅:D[7.1066] → [2.1474:3139]

                                    // future to wait for online
                                    Box::new(
                                        XmppConnection {
                                            state: XmppState {
                                                client,
                                                data: std::default::Default::default(),
                                            },
                                            account,
                                        }
                                        .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)),
                                            },
                                        ),
                                    )

[7.1066]

[6.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 135 [5.17]

∅:D[6.3162] → [2.3140:3170]

[6.3162]

[6.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))
                                .and_then(|conn| conn.enter_mucs(stop_future4))
                                .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 168 [5.17]

∅:D[6.3788] → [2.3171:3306]

    fn xmpp_processing(
        self,
        event: &Event,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {

[6.3788]

[3.4545]

    /// Returns false on error to disconnect
    fn xmpp_processing(&mut self, event: &Event) -> bool {

Replacement in src/xmpp/mod.rs at line 173 [5.17]

∅:D[2.3369] → [2.3369:3437]

∅:D[2.3437] → [3.4606:4712]

∅:D[3.4606] → [3.4606:4712]

∅:D[3.4712] → [2.3438:3603]

                processors.incoming.process(self, stanza.clone());
                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> {}
                future::ok(self)

[2.3369]

[3.8539]

                processors.incoming.process(self, stanza.clone())

Replacement in src/xmpp/mod.rs at line 175 [5.17]

∅:D[3.8553] → [2.3604:3651]

            Event::Online => future::ok(self),

[3.8553]

[3.8600]

            Event::Online => true,

Replacement in src/xmpp/mod.rs at line 178 [5.17]

∅:D[3.8670] → [2.3652:3694]

                future::err(self.account)

[3.8670]

[3.8712]

                false
            }
        }
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        use std::convert::TryInto;
        if let Some((_, jid)) = self.state.data.pending_add_roster_ids.remove_entry(&iq.id) {
            if let xmpp_parsers::iq::IqType::Result(None) = iq.payload {
                if self.state.data.roster.contains_key(&jid) {
                    info!("Jid {} updated to roster", jid);
                } else {
                    info!("Jid {} added in roster", jid);
                    self.state.data.roster.insert(
                        jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                self.process_jid(&jid);
            } else {
                warn!(
                    "Wrong payload when adding {} to roster: {:?}",
                    jid, iq.payload
                );
            }
        }
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                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;
                            rdata.1 = i.ask;
                        } else {
                            info!("Add {} to roster", i.jid);
                            self.state
                                .data
                                .roster
                                .insert(i.jid.clone(), (i.subscription, i.ask));
                        }
                        self.process_jid(&i.jid);
                    }
                }
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                if let Some(_ping) = element.try_into().ok() as Option<xmpp_parsers::ping::Ping> {
                    let pong = stanzas::make_pong(&iq.id, self.state.client.jid.clone(), iq.from);
                    self.state.data.send_queue.push_back(pong);
                }

Insertion in src/xmpp/mod.rs at line 238 [5.17]
[3.8726]
[3.8726]
```
            _ => (), // ignore
```
Insertion in src/xmpp/mod.rs at line 240 [5.17]
[3.8736]
[7.2124]
```
        true
```

Replacement in src/xmpp/mod.rs at line 266 [5.17]

∅:D[3.9205] → [2.3695:3750]

                    state: XmppState { client, data },

[3.9205]

[3.9264]

                    state: XmppState { client, mut data },

Replacement in src/xmpp/mod.rs at line 269 [5.17]

∅:D[3.9319] → [2.3751:6822]

                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)))
                        }),
                    })

[3.9319]

[8.5580]


                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {:?}", send_element);
                    Box::new(
                        client
                            .send(Packet::Stanza(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))))
                                    }
                                })),
                                Err(Either::A((e, b))) => {
                                    warn!("XMPP sending error: {}", e);
                                    Box::new(future::err((account, Ok(Either::A(b)))))
                                }
                                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 mut xmpp = XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        };
                                        if 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,
                                                ))),
                                                Err(_e) => {
                                                    future::err((xmpp.account, Ok(Either::A(b))))
                                                }
                                            }
                                        } else {
                                            future::err((xmpp.account, Ok(Either::A(b))))
                                        }
                                    } else {
                                        future::err((account, Ok(Either::A(b))))
                                    }
                                }
                                Ok(Either::B((t, a))) => {
                                    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);
                                    future::err((account, Ok(Either::A(b))))
                                }
                                Err(Either::B((e, a))) => {
                                    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 413 [5.17]

∅:D[3.16485] → [2.6823:6900]

    fn process_initial_roster(&mut self, event: Event) -> Result<bool, ()> {

[3.16485]

[3.16562]

    fn process_initial_roster(&mut self, event: Event, id_init_roster: &str) -> Result<bool, ()> {

Replacement in src/xmpp/mod.rs at line 415 [5.17]
∅:D[3.16604] → [2.6901:6936]
```
            use try_from::TryInto;
```
[3.16604]
[3.16639]
```
            use std::convert::TryInto;
```

Replacement in src/xmpp/mod.rs at line 418 [5.17]

∅:D[3.16735] → [2.6937:8330]

                    if let Some(id) = iq.id {
                        if id == ID_GET_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, ());
                                            }
                                            Ok(true)
                                        }
                                        Err(e) => {
                                            error!("Cann't parse roster: {}", e);
                                            Err(())

[3.16735]

[3.18104]

                    if iq.id == 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, i.ask));

Insertion in src/xmpp/mod.rs at line 436 [5.17]

[3.18146]

[3.18374]

                                        Ok(true)

Insertion in src/xmpp/mod.rs at line 438 [5.17]

[3.18412]

[9.6991]

                                    Err(e) => {
                                        error!("Cann't parse roster: {}", e);
                                        Err(())
                                    }

Replacement in src/xmpp/mod.rs at line 443 [5.17]

∅:D[9.7025] → [2.8331:8520]

                                _ => {
                                    error!("Unknown result of roster");
                                    Err(())
                                }

[9.7025]

[10.7921]

                            }
                            _ => {
                                error!("Unknown result of roster");
                                Err(())

Deletion in src/xmpp/mod.rs at line 448 [5.17]

∅:D[10.7951] → [2.8521:8592]

                        } else {
                            Ok(false)

Replacement in src/xmpp/mod.rs at line 450 [5.17]

∅:D[3.18791] → [2.8593:8681]

                        error!("Iq stanza without id");
                        Err(())

[3.18791]

[3.18879]

                        Ok(false)

Replacement in src/xmpp/mod.rs at line 471 [5.17]

∅:D[3.19318] → [2.8682:8729]

            state: XmppState { client, data },

[3.19318]

[3.19369]

            state: XmppState { client, mut data },

Replacement in src/xmpp/mod.rs at line 475 [5.17]

∅:D[11.8525] → [2.8730:8796]

        let get_roster = stanzas::make_get_roster(ID_GET_ROSTER);

[11.8525]

[3.19641]

        data.counter += 1;
        let id_init_roster = format!("id_init_roster{}", data.counter);
        let get_roster = stanzas::make_get_roster(&id_init_roster);

Replacement in src/xmpp/mod.rs at line 482 [5.17]

∅:D[3.19750] → [2.8797:8827]

            .send(get_roster)

[3.19750]

[3.19780]

            .send(Packet::Stanza(get_roster))

Replacement in src/xmpp/mod.rs at line 492 [5.17]

∅:D[3.20084] → [2.8828:8909]

                .processing(XmppConnection::process_initial_roster, stop_future)

[3.20084]

[3.20165]

                .processing(
                    move |conn, event| conn.process_initial_roster(event, &id_init_roster),
                    stop_future,
                )

Replacement in src/xmpp/mod.rs at line 524 [5.17]
∅:D[12.6667] → [2.8910:8938]
```
            .send(presence)
```
[12.6667]
[7.8226]
```
            .send(Packet::Stanza(presence))
```

Replacement in src/xmpp/mod.rs at line 537 [5.17]

∅:D[7.8658] → [2.8939:9323]

                            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)

[7.8658]

[7.9042]

                            use std::convert::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)
                                }

Replacement in src/xmpp/mod.rs at line 563 [5.17]

∅:D[3.21632] → [2.9324:9463]

    fn process_command(
        self,
        cmd: &XmppCommand,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>> {

[3.21632]

[3.21686]

    fn process_jid(&mut self, xmpp_to: &xmpp_parsers::Jid) {
        if let Some(ref mut mailbox) = self.state.data.outgoing_mailbox.get_mut(xmpp_to) {
            if !mailbox.is_empty() {
                if let Some(ref mut rdata) = self.state.data.roster.get_mut(xmpp_to) {
                    info!("Jid {} in roster", 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 {}", xmpp_to);
                        self.state.data.send_queue.extend(
                            mailbox.drain(..).map(|message| {
                                stanzas::make_chat_message(xmpp_to.clone(), message)
                            }),
                        );
                    } else if rdata.1 == xmpp_parsers::roster::Ask::None {
                        info!("Not subscribed to {}", xmpp_to);
                        self.state
                            .data
                            .send_queue
                            .push_back(stanzas::make_ask_subscribe(xmpp_to.clone()));
                    }
                } else {
                    info!("Jid {} not in roster", 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, xmpp_to.clone());
                    self.state
                        .data
                        .pending_add_roster_ids
                        .insert(id_add_roster, xmpp_to.clone());
                    info!("Adding jid to roster... {:?}", add_roster);
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    fn process_command(&mut self, cmd: XmppCommand) {

Replacement in src/xmpp/mod.rs at line 607 [5.17]

∅:D[3.21716] → [2.9464:9665]

        if let Some(_jid_data) = self.state.data.roster.get(&cmd.xmpp_to) {
            info!("Jid {} in roster", cmd.xmpp_to);
        } else {
            info!("Jid {} not in roster", cmd.xmpp_to);

[3.21716]

[3.23186]

        match cmd {
            XmppCommand::Chat { xmpp_to, message } => {
                self.state
                    .data
                    .outgoing_mailbox
                    .entry(xmpp_to.clone())
                    .or_default()
                    .push(message);
                self.process_jid(&xmpp_to);
            }
            XmppCommand::Chatroom { muc_id, message } => {
                if let Some(muc) = self.state.data.mucs.get(&muc_id) {
                    self.state
                        .data
                        .send_queue
                        .push_back(stanzas::make_muc_message(muc.clone(), message));
                } else {
                    error!("Not found MUC {}", muc_id);
                }
            }
            XmppCommand::Ping => {
                self.state.data.counter += 1;
                let id_ping = format!("id_ping{}", self.state.data.counter);
                let ping = stanzas::make_ping(&id_ping, self.state.client.jid.clone());
                self.state.data.send_queue.push_back(ping);
            }

Replacement in src/xmpp/mod.rs at line 634 [5.17]

∅:D[3.23196] → [2.9666:9691]

        future::ok(self)

[3.23196]

[13.5042]

    }
    fn shutdown(self) -> impl Future<Item = (), Error = failure::Error> {
        info!("Shutdown connection");
        let XmppConnection { account, state } = self;
        stream::iter_ok(
            state
                .data
                .mucs
                .values()
                .map(std::clone::Clone::clone)
                .collect::<Vec<_>>(),
        )
        .fold(state, move |XmppState { client, data }, muc_jid| {
            let muc_presence =
                stanzas::make_muc_presence_leave(account.jid.clone(), muc_jid.clone());
            info!("Sending muc leave presence... {:?}", muc_presence);
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,
    {
        let XmppConnection { account, state } = self;
        let account2 = account.clone();
        let account3 = account.clone();
        stream::iter_ok(account.chatrooms.clone())
            .fold(state, move |XmppState { client, mut data }, muc_jid| {
                data.counter += 1;
                let id_muc_presence = format!("id_muc_presence{}", data.counter);
                let muc_presence = stanzas::make_muc_presence(
                    &id_muc_presence,
                    account2.jid.clone(),
                    muc_jid.1.clone(),
                );
                info!("Sending muc presence... {:?}", muc_presence);
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })

Replacement in src/xmpp/mod.rs at line 711 [5.17]

∅:D[14.60] → [2.9692:9716]

pub struct XmppCommand;

[14.60]

[5.3816]

pub enum XmppCommand {
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    Chatroom {
        muc_id: String,
        message: String,
    },
    Ping,
}

Replacement in src/xmpp/mod.rs at line 761 [5.17]

∅:D[3.23809] → [2.9717:10314]

                    Ok((conn, r)) => match r {
                        Ok(Either::A(f)) => Box::new(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"))
                        })
                            as Box<dyn Future<Item = _, Error = _>>,

[3.23809]

[3.24419]

                    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 {
                                error!("Command receiver is gone");
                                future::ok(future::Loop::Break(Some(conn)))
                            }
                        }

Replacement in src/xmpp/mod.rs at line 776 [5.17]

∅:D[3.24532] → [2.10315:10865]

                                Box::new(conn.process_command(&cmd).then(|r| {
                                    future::ok(future::Loop::Continue(XmppProcessState {
                                        cmd_recv,
                                        signal,
                                        conn: match r {
                                            Ok(conn) => conn.into(),
                                            Err(account) => account.into(),
                                        },
                                    }))

[3.24532]

[3.24822]

                                conn.process_command(cmd);
                                future::ok(future::Loop::Continue(XmppProcessState {
                                    cmd_recv,
                                    signal,
                                    conn: conn.into(),

Deletion in src/xmpp/mod.rs at line 783 [5.17]

∅:D[3.24858] → [2.10866:10942]

                                    as Box<dyn Future<Item = _, Error = _>>

Replacement in src/xmpp/mod.rs at line 784 [5.17]

∅:D[3.24895] → [2.10943:11021]

                                Box::new(future::ok(future::Loop::Break(())))

[3.24895]

[3.24963]

                                future::ok(future::Loop::Break(Some(conn)))

Replacement in src/xmpp/mod.rs at line 787 [5.17]

∅:D[15.2257] → [2.11022:11122]

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

[15.2257]

[3.25109]

                        Err(_) => {
                            error!("Command receiver is broken");
                            future::ok(future::Loop::Break(Some(conn)))
                        }

Replacement in src/xmpp/mod.rs at line 792 [5.17]

∅:D[3.25132] → [2.11123:11183]

                    Err((account, r)) => Box::new(match r {

[3.25132]

[3.25183]

                    Err((account, r)) => match r {

Replacement in src/xmpp/mod.rs at line 813 [5.17]

∅:D[3.26249] → [2.11184:11252]

                                future::ok(future::Loop::Break(()))

[3.26249]

[3.26317]

                                future::ok(future::Loop::Break(None))

Replacement in src/xmpp/mod.rs at line 817 [5.17]
∅:D[3.26438] → [2.11253:11277]
```
                    }),
```
[3.26438]
[3.26461]
```
                    },
```

Insertion in src/xmpp/mod.rs at line 820 [5.17]

[3.26491]

[10.10542]

    })
    .and_then(|opt_conn| {
        if let Some(conn) = opt_conn {
            Box::new(conn.shutdown()) as Box<dyn Future<Item = (), Error = _>>
        } else {
            Box::new(future::ok(()))
        }

Replacement in src/xmpp/element_processor.rs at line 0 [2.11301]

∅:D[2.11301] → [2.11302:12350]

pub struct Processor<S: 'static, T: 'static, E: Clone + 'static> {
    processors: Vec<Box<dyn Fn(&mut S, E) -> Option<T>>>,
    default: &'static dyn Fn(&mut S, E) -> T,
}
impl<S: 'static, T: 'static, E: Clone + 'static> Processor<S, T, E> {
    pub fn new<F>(f: &'static F) -> Processor<S, T, E>
    where
        F: Fn(&mut S, E) -> T + 'static,
    {
        Processor {
            processors: vec![],
            default: f,
        }
    }
    pub fn register<F, A>(&mut self, f: &'static F)
    where
        F: Fn(&mut S, A) -> T + 'static,
        A: std::convert::TryFrom<E>,
    {
        self.processors.push(Box::new(move |s, e: E| {
            use std::convert::TryInto;
            (e.try_into().ok() as Option<A>).map(|a| f(s, a))
        }));
    }
    pub fn process(&self, s: &mut S, e: E) -> T {
        for processor in self.processors.iter() {
            match processor(s, e.clone()) {
                Some(t) => return t,
                None => continue,
            }
        }
        (*self.default)(s, e)
    }
}

[2.11301]

type Func<S, T, E> = dyn Fn(&mut S, E) -> T;
pub struct Processor<S: 'static, T: 'static, E: Clone + 'static> {
    processors: Vec<Box<Func<S, Option<T>, E>>>,
    default: &'static Func<S, T, E>,
}
impl<S: 'static, T: 'static, E: Clone + 'static> Processor<S, T, E> {
    pub fn new<F>(f: &'static F) -> Processor<S, T, E>
    where
        F: Fn(&mut S, E) -> T + 'static,
    {
        Processor {
            processors: vec![],
            default: f,
        }
    }
    pub fn register<F, A>(&mut self, f: &'static F)
    where
        F: Fn(&mut S, A) -> T + 'static,
        A: std::convert::TryFrom<E>,
    {
        self.processors.push(Box::new(move |s, e: E| {
            use std::convert::TryInto;
            (e.try_into().ok() as Option<A>).map(|a| f(s, a))
        }));
    }
    pub fn process(&self, s: &mut S, e: E) -> T {
        for processor in self.processors.iter() {
            match processor(s, e.clone()) {
                Some(t) => return t,
                None => continue,
            }
        }
        (*self.default)(s, e)
    }
}

Insertion in src/main.rs at line 2 [17.17]
[16.3885]
[16.3885]
```
#![deny(bare_trait_objects)]
```
Deletion in src/main.rs at line 8 [17.17]
∅:D[18.3621] → [2.12351:12373]
```
extern crate minidom;
```
Deletion in src/main.rs at line 22 [17.17]
∅:D[18.3921] → [2.12374:12406]
```
use hyper::service::service_fn;
```
Replacement in src/main.rs at line 27 [17.17]
∅:D[16.4155] → [2.12407:12433]
```
use tokio::prelude::Sink;
```
[16.4155]
[18.4092]
```
use tokio::prelude::{Future, Sink, Stream};
```

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

[16.4337]

[13.8026]


fn body_to_string(req: Request<Body>) -> impl Future<Item = String, Error = failure::Error> {
    req.into_body()
        .map_err(std::convert::Into::into)
        .fold(String::new(), |mut acc, ch| {
            std::str::from_utf8(&*ch).map(|s| {
                acc.push_str(s);
                acc
            })
        })
}
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(std::convert::Into::into)
                    .and_then(|s| std::str::FromStr::from_str(s).map_err(std::convert::Into::into))
            },
        );
        let xmpp_muc_opt = req
            .headers()
            .get("X-XMPP-Muc")
            .map(|h| h.to_str().map(std::string::ToString::to_string));

Insertion in src/main.rs at line 76 [17.17]

[13.8027]

[17.18]

        match (xmpp_muc_opt, xmpp_to_res) {
            (None, 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(std::convert::Into::into),
                )) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
            (None, Ok(xmpp_to)) => {
                info!("Got request. Reading body...");
                let cmd_send = self.cmd_send.clone();
                Box::new(body_to_string(req).and_then(move |message: String| {
                    if !message.is_empty() {
                        Box::new(
                            cmd_send
                                .clone()
                                .send(XmppCommand::Chat { 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(std::convert::Into::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(std::convert::Into::into),
                        ))
                            as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                    }
                })) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
            (Some(Ok(muc_id)), _) => {
                info!("Got MUC request. Reading body...");
                let cmd_send = self.cmd_send.clone();
                Box::new(body_to_string(req).and_then(move |message: String| {
                    if !message.is_empty() {
                        Box::new(
                            cmd_send
                                .clone()
                                .send(XmppCommand::Chatroom { muc_id, 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(std::convert::Into::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(std::convert::Into::into),
                        ))
                            as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                    }
                })) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
            (Some(Err(err)), _) => {
                warn!("Unknown MUC destination: {}", err);
                Box::new(tokio::prelude::future::result(
                    Response::builder()
                        .status(hyper::StatusCode::BAD_REQUEST)
                        .body(Body::from(format!("Unknown MUC destination: {}", err)))
                        .map_err(std::convert::Into::into),
                )) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
        }
    }
}
struct MakeServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
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 229 [17.17]

∅:D[18.5155] → [2.12434:13203]

        .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))),
                        )
                    }
                })
            })

[18.5155]

[10.11293]

        .serve(MakeServiceCmd {
            cmd_send: cmd_send.clone(),

Insertion in src/main.rs at line 237 [17.17]

[18.6049]

[16.5562]

    if let Some(ping) = config.account.ping {
        let ping = tokio::timer::Interval::new_interval(std::time::Duration::from_secs(ping));
        rt.spawn(
            ping.map_err(|e| {
                error!("Ping error: {}", e);
            })
            .for_each(move |_| {
                cmd_send
                    .clone()
                    .send(XmppCommand::Ping)
                    .map_err(|e| {
                        error!("Ping command error: {}", e);
                    })
                    .map(|_| ())
            })
            .select(
                ctrl_c
                    .clone()
                    .map(|_| ())
                    .map_err(|e| error!("ping server error: {}", e)),
            )
            .map(|_| ())
            .map_err(|_| ()),
        );
    }

Insertion in src/config.rs at line 0 [19.1396]
[19.1396]
[19.1397]
```
use std::collections::HashMap;
```

Replacement in src/config.rs at line 7 [19.1396]

∅:D[19.1502] → [2.13204:13225]

    pub jid: String,

[19.1502]

[19.1523]

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

Insertion in src/config.rs at line 10 [19.1396]

[19.1549]

    #[serde(default, deserialize_with = "deserialize_jid_map")]
    pub chatrooms: HashMap<String, xmpp_parsers::Jid>,
    pub ping: Option<u64>,

Insertion in src/config.rs at line 30 [19.1396]

[19.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)
}
fn deserialize_jid_map<'de, D>(
    deserializer: D,
) -> Result<HashMap<String, xmpp_parsers::Jid>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    use serde::Deserialize;
    let s = HashMap::<String, String>::deserialize(deserializer)?;
    let size = s.len();
    s.into_iter()
        .map(|(k, v)| (k, std::str::FromStr::from_str(&v)))
        .take_while(|(_k, r)| r.is_ok())
        .fold(Ok(HashMap::with_capacity(size)), |res, (k, r)| match res {
            Ok(mut res) => match r {
                Ok(v) => {
                    res.insert(k, v);
                    Ok(res)
                }
                Err(e) => Err(e),
            },
            Err(e) => Err(e),
        })
        .map_err(serde::de::Error::custom)

Insertion in README.md at line 0 [17.76]

[17.76]

### XMPP client daemon
#### Sending messages
```
curl http://localhost:8083/ -H "X-XMPP-To: some@domain.org" -d "Test"
```
#### Sending messages to MUC
```
curl http://localhost:8083/ -H "X-XMPP-Muc: smac" -d "Test"
```

Replacement in Cargo.toml at line 12 [17.11995]
∅:D[18.6900] → [2.13226:13261]
```
tokio-xmpp = "0.2"
failure = "0.1"
```
[18.6900]
[18.6935]
```
tokio-xmpp = "1.0.0"
failure = "0.1.5"
```
Replacement in Cargo.toml at line 15 [17.11995]
∅:D[18.6950] → [2.13262:13275]
```
toml = "0.4"
```
[18.6950]
[18.6963]
```
toml = "0.5"
```

Replacement in Cargo.toml at line 21 [17.11995]

∅:D[16.6425] → [2.13276:13394]

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

[16.6425]

xmpp-parsers = "0.13"
minidom = "=0.10.0" # xmpp-parsers

Insertion in Cargo.lock at line 0 [17.12201]

[17.12201]

[16.6543]

# This file is automatically @generated by Cargo.
# It is not intended for manual editing.

Insertion in Cargo.lock at line 3 [17.12201]

[16.6555]

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

Replacement in Cargo.lock at line 12 [17.12201]
∅:D[16.6577] → [2.13395:13413]
```
version = "0.6.9"
```
[16.6577]
[16.6595]
```
version = "0.7.3"
```

Replacement in Cargo.lock at line 15 [17.12201]

∅:D[16.6677] → [2.13414:13487]

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

[16.6677]

[16.6750]

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

Replacement in Cargo.lock at line 23 [17.12201]

∅:D[18.7455] → [2.13488:13561]

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

[18.7455]

[18.7528]

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

Replacement in Cargo.lock at line 28 [17.12201]
∅:D[18.7561] → [2.13562:13580]
```
version = "0.3.6"
```
[18.7561]
[2.13580]
```
version = "0.3.10"
```
Deletion in Cargo.lock at line 32 [17.12201]
∅:D[2.13658] → [2.13658:13694]
∅:D[10.13512] → [20.1388:1466]
∅:D[21.19557] → [20.1388:1466]
∅:D[2.13694] → [20.1388:1466]
∅:D[22.14414] → [20.1388:1466]
∅:D[23.4795] → [20.1388:1466]
∅:D[16.6772] → [20.1388:1466]
∅:D[20.1388] → [20.1388:1466]
```
name = "arrayref"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
```
Replacement in Cargo.lock at line 33 [17.12201]
∅:D[18.7789] → [2.13695:13713]
```
version = "0.4.8"
```
[18.7789]
[18.7807]
```
version = "0.4.10"
```

Replacement in Cargo.lock at line 44 [17.12201]

∅:D[18.8093] → [2.13714:13786]

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

[18.8093]

[18.8165]

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

Replacement in Cargo.lock at line 46 [17.12201]

∅:D[18.8239] → [2.13787:13860]

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

[18.8239]

[18.8312]

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

Replacement in Cargo.lock at line 50 [17.12201]
∅:D[24.10388] → [2.13861:13898]
```
name = "backtrace"
version = "0.2.3"
```
[24.10388]
[18.8364]
```
name = "autocfg"
version = "0.1.2"
```

Deletion in Cargo.lock at line 53 [17.12201]

∅:D[18.8429] → [2.13899:14455]

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 56 [17.12201]
∅:D[18.9017] → [2.14456:14474]
```
version = "0.3.9"
```
[18.9017]
[18.9035]
```
version = "0.3.15"
```

Replacement in Cargo.lock at line 59 [17.12201]

∅:D[18.9117] → [2.14475:14855]

 "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)",
 "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.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[18.9117]

[18.9497]

 "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)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 69 [17.12201]
∅:D[18.9535] → [2.14856:14875]
```
version = "0.1.24"
```
[18.9535]
[18.9554]
```
version = "0.1.28"
```

Replacement in Cargo.lock at line 72 [17.12201]

∅:D[18.9636] → [2.14876:15018]

 "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)",

[18.9636]

[18.9778]

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

Replacement in Cargo.lock at line 78 [17.12201]
∅:D[18.9809] → [2.15019:15037]
```
version = "0.9.3"
```
[18.9809]
[18.9827]
```
version = "0.10.1"
```

Replacement in Cargo.lock at line 81 [17.12201]

∅:D[18.9909] → [2.15038:15188]

 "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)",

[18.9909]

[18.10059]

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

Replacement in Cargo.lock at line 91 [17.12201]
∅:D[18.10204] → [2.15189:15207]
```
version = "0.7.1"
```
[18.10204]
[18.10222]
```
version = "0.8.0"
```

Replacement in Cargo.lock at line 94 [17.12201]

∅:D[18.10304] → [2.15208:15435]

 "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)",

[18.10304]

[18.10531]

 "byte-tools 0.3.1 (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.2 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 102 [17.12201]

∅:D[18.10568] → [2.15436:15454]

version = "0.3.3"

[18.10568]

[22.15479]

version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "block-padding 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (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.3"

Replacement in Cargo.lock at line 116 [17.12201]

∅:D[22.15561] → [2.15455:15607]

 "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)",

[22.15561]

[21.20937]

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

Replacement in Cargo.lock at line 121 [17.12201]
∅:D[18.10855] → [2.15608:15626]
```
version = "0.2.0"
```
[18.10855]
[18.10873]
```
version = "0.3.1"
```
Replacement in Cargo.lock at line 126 [17.12201]
∅:D[18.10970] → [2.15627:15645]
```
version = "1.2.7"
```
[18.10970]
[18.10988]
```
version = "1.3.1"
```
Replacement in Cargo.lock at line 131 [17.12201]
∅:D[18.11081] → [2.15646:15665]
```
version = "0.4.11"
```
[18.11081]
[18.11100]
```
version = "0.4.12"
```

Replacement in Cargo.lock at line 134 [17.12201]

∅:D[18.11182] → [2.15666:15742]

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

[18.11182]

[18.11258]

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

Replacement in Cargo.lock at line 145 [17.12201]
∅:D[18.11467] → [2.15743:15762]
```
version = "1.0.25"
```
[18.11467]
[18.11486]
```
version = "1.0.35"
```
Replacement in Cargo.lock at line 150 [17.12201]
∅:D[18.11580] → [2.15763:15781]
```
version = "0.1.6"
```
[18.11580]
[18.11598]
```
version = "0.1.7"
```

Replacement in Cargo.lock at line 160 [17.12201]

∅:D[18.11948] → [2.15782:15854]

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

[18.11948]

[18.12020]

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

Replacement in Cargo.lock at line 165 [17.12201]
∅:D[18.12049] → [2.15855:15874]
```
version = "2.32.0"
```
[18.12049]
[18.12068]
```
version = "2.33.0"
```

Replacement in Cargo.lock at line 171 [17.12201]

∅:D[18.12374] → [2.15875:16024]

 "strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "textwrap 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",

[18.12374]

[18.12523]

 "strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",

Deletion in Cargo.lock at line 184 [17.12201]

∅:D[18.12887] → [2.16025:16147]


[[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 191 [17.12201]

∅:D[18.13233] → [2.16148:16220]

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

[18.13233]

[18.13305]

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

Replacement in Cargo.lock at line 199 [17.12201]

∅:D[9.10117] → [2.16221:16293]

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

[9.10117]

[18.13825]

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

Replacement in Cargo.lock at line 204 [17.12201]
∅:D[9.10219] → [2.16294:16312]
```
version = "0.6.2"
```
[9.10219]
[18.13883]
```
version = "0.7.1"
```

Replacement in Cargo.lock at line 207 [17.12201]

∅:D[18.13965] → [2.16313:16477]

 "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)",

[18.13965]

[13.15736]

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

Replacement in Cargo.lock at line 213 [17.12201]
∅:D[9.10346] → [2.16478:16496]
```
version = "0.6.1"
```
[9.10346]
[13.15794]
```
version = "0.7.1"
```

Replacement in Cargo.lock at line 216 [17.12201]

∅:D[13.15876] → [2.16497:16805]

 "arrayvec 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",

[13.15876]

[9.10593]

 "arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 225 [17.12201]
∅:D[18.14441] → [2.16806:16849]
```
name = "crossbeam-utils"
version = "0.6.1"
```
[18.14441]
[10.14733]
```
name = "crossbeam-queue"
version = "0.1.2"
```

Replacement in Cargo.lock at line 229 [17.12201]

∅:D[10.14815] → [2.16850:16923]

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

[10.14815]

[10.14897]

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

Replacement in Cargo.lock at line 233 [17.12201]
∅:D[10.14912] → [2.16924:16962]
```
name = "crypto-mac"
version = "0.5.2"
```
[10.14912]
[20.4227]
```
name = "crossbeam-utils"
version = "0.6.5"
```

Replacement in Cargo.lock at line 237 [17.12201]

∅:D[16.7801] → [2.16963:17126]

 "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)",

[16.7801]

[16.7874]

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 242 [17.12201]
∅:D[20.4305] → [2.17127:17166]
```
name = "dbghelp-sys"
version = "0.2.0"
```
[20.4305]
[23.7366]
```
name = "crypto-mac"
version = "0.7.0"
```

Replacement in Cargo.lock at line 246 [17.12201]

∅:D[23.7448] → [2.17167:17319]

 "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)",

[23.7448]

[23.7611]

 "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)",

Replacement in Cargo.lock at line 262 [17.12201]
∅:D[18.15609] → [2.17320:17338]
```
version = "0.7.6"
```
[18.15609]
[18.15627]
```
version = "0.8.0"
```

Replacement in Cargo.lock at line 265 [17.12201]

∅:D[18.15709] → [2.17339:17419]

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

[18.15709]

[18.15789]

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

Replacement in Cargo.lock at line 270 [17.12201]
∅:D[18.15825] → [2.17420:17439]
```
version = "0.8.12"
```
[18.15825]
[18.15844]
```
version = "0.8.17"
```

Replacement in Cargo.lock at line 273 [17.12201]

∅:D[18.15926] → [2.17440:17513]

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

[18.15926]

[16.7897]

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 278 [17.12201]
∅:D[16.7932] → [2.17514:17532]
```
version = "0.6.0"
```
[16.7932]
[16.7950]
```
version = "0.6.1"
```

Replacement in Cargo.lock at line 284 [17.12201]

∅:D[16.8250] → [2.17533:17605]

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

[16.8250]

[16.8322]

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

Deletion in Cargo.lock at line 290 [17.12201]

∅:D[20.4842] → [2.17606:17819]

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 [17.12201]

∅:D[18.16849] → [2.17820:17896]

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

[18.16849]

[18.16925]

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

Replacement in Cargo.lock at line 298 [17.12201]
∅:D[18.16957] → [2.17897:17915]
```
version = "0.1.3"
```
[18.16957]
[18.16975]
```
version = "0.1.5"
```

Replacement in Cargo.lock at line 301 [17.12201]

∅:D[18.17057] → [2.17916:18073]

 "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)",

[18.17057]

[18.17214]

 "backtrace 0.3.15 (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 [17.12201]
∅:D[18.17253] → [2.18074:18092]
```
version = "0.1.3"
```
[18.17253]
[18.17271]
```
version = "0.1.5"
```

Replacement in Cargo.lock at line 310 [17.12201]

∅:D[18.17353] → [2.18093:18317]

 "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)",

[18.17353]

[16.8623]

 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",

Insertion in Cargo.lock at line 336 [17.12201]

[18.18151]

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

Replacement in Cargo.lock at line 364 [17.12201]

∅:D[18.18854] → [2.18318:18406]

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

[18.18854]

[18.18942]

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

Replacement in Cargo.lock at line 369 [17.12201]
∅:D[18.18974] → [2.18407:18426]
```
version = "0.1.25"
```
[18.18974]
[18.18993]
```
version = "0.1.26"
```

Replacement in Cargo.lock at line 377 [17.12201]

∅:D[18.19196] → [2.18427:18577]

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

[18.19196]

[18.19346]

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

Replacement in Cargo.lock at line 383 [17.12201]
∅:D[18.19384] → [2.18578:18596]
```
version = "0.9.0"
```
[18.19384]
[18.19402]
```
version = "0.12.0"
```
Replacement in Cargo.lock at line 391 [17.12201]
∅:D[18.19586] → [2.18597:18616]
```
version = "0.1.14"
```
[18.19586]
[18.19605]
```
version = "0.1.18"
```

Replacement in Cargo.lock at line 394 [17.12201]

∅:D[18.19687] → [2.18617:18766]

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

[18.19687]

[18.19836]

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

Replacement in Cargo.lock at line 397 [17.12201]

∅:D[18.19906] → [2.18767:18914]

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

[18.19906]

[18.20053]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 401 [17.12201]

∅:D[16.8941] → [2.18915:19135]

 "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)",

[16.8941]

[22.18475]

 "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.12 (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 420 [17.12201]

∅:D[18.20551] → [2.19136:19208]

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

[18.20551]

[18.20623]

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

Replacement in Cargo.lock at line 426 [17.12201]
∅:D[18.20726] → [2.19209:19228]
```
version = "0.1.14"
```
[18.20726]
[18.20745]
```
version = "0.1.17"
```

Replacement in Cargo.lock at line 429 [17.12201]

∅:D[18.20827] → [2.19229:19302]

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

[18.20827]

[18.20900]

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

Replacement in Cargo.lock at line 449 [17.12201]
∅:D[18.21397] → [2.19303:19323]
```
version = "0.12.17"
```
[18.21397]
[18.21417]
```
version = "0.12.27"
```

Replacement in Cargo.lock at line 452 [17.12201]

∅:D[18.21499] → [2.19324:19472]

 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

[18.21499]

[18.21647]

 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 455 [17.12201]

∅:D[18.21729] → [2.19473:19615]

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

[18.21729]

[18.21871]

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

Replacement in Cargo.lock at line 462 [17.12201]

∅:D[18.22231] → [2.19616:20235]

 "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)",
 "tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",

[18.22231]

[18.22850]

 "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (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.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 481 [17.12201]

∅:D[18.23203] → [2.20236:20324]

 "unicode-normalization 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

[18.23203]

[18.23291]

 "unicode-normalization 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 494 [17.12201]

∅:D[18.23535] → [2.20325:20397]

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

[18.23535]

[18.23607]

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

Replacement in Cargo.lock at line 506 [17.12201]

∅:D[18.24042] → [2.20398:20471]

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

[18.24042]

[18.24115]

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

Replacement in Cargo.lock at line 517 [17.12201]
∅:D[18.24326] → [2.20472:20490]
```
version = "0.5.2"
```
[18.24326]
[18.24344]
```
version = "0.5.3"
```

Replacement in Cargo.lock at line 520 [17.12201]

∅:D[18.24426] → [2.20491:20720]

 "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)",

[18.24426]

[18.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 541 [17.12201]
∅:D[18.25092] → [2.20721:20739]
```
version = "1.2.0"
```
[18.25092]
[18.25110]
```
version = "1.3.0"
```
Replacement in Cargo.lock at line 551 [17.12201]
∅:D[18.25316] → [2.20740:20759]
```
version = "0.2.44"
```
[18.25316]
[18.25335]
```
version = "0.2.51"
```
Replacement in Cargo.lock at line 556 [17.12201]
∅:D[18.25438] → [2.20760:20778]
```
version = "0.4.2"
```
[18.25438]
[18.25456]
```
version = "0.5.2"
```

Replacement in Cargo.lock at line 573 [17.12201]

∅:D[18.25934] → [2.20779:20852]

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

[18.25934]

[18.26007]

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 578 [17.12201]
∅:D[18.26041] → [2.20853:20871]
```
version = "0.1.1"
```
[18.26041]
[18.26059]
```
version = "0.1.2"
```

Replacement in Cargo.lock at line 581 [17.12201]

∅:D[18.26141] → [2.20872:20954]

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

[18.26141]

[18.26223]

 "linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 591 [17.12201]
∅:D[18.26368] → [2.20955:20973]
```
version = "0.7.3"
```
[18.26368]
[18.26386]
```
version = "0.7.5"
```

Replacement in Cargo.lock at line 594 [17.12201]

∅:D[18.26468] → [2.20974:21355]

 "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)",

[18.26468]

[18.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.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 601 [17.12201]

∅:D[18.27015] → [2.21356:21430]

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

[18.27015]

[18.27089]

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

Replacement in Cargo.lock at line 611 [17.12201]
∅:D[18.27233] → [2.21431:21449]
```
version = "2.1.1"
```
[18.27233]
[18.27251]
```
version = "2.2.0"
```

Deletion in Cargo.lock at line 613 [17.12201]

∅:D[18.27316] → [2.21450:21694]

dependencies = [
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
]

Replacement in Cargo.lock at line 621 [17.12201]
∅:D[18.27705] → [2.21695:21713]
```
version = "0.9.1"
```
[18.27705]
[18.27723]
```
version = "0.10.0"
```

Replacement in Cargo.lock at line 624 [17.12201]

∅:D[18.27805] → [2.21714:21946]

 "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)",

[18.27805]

[18.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.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 639 [17.12201]

∅:D[16.10535] → [2.21947:22019]

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

[16.10535]

[16.10607]

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

Replacement in Cargo.lock at line 643 [17.12201]

∅:D[18.28843] → [2.22020:22091]

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

[18.28843]

[18.28914]

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

Replacement in Cargo.lock at line 653 [17.12201]

∅:D[18.29191] → [2.22092:22164]

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

[18.29191]

[18.29263]

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

Replacement in Cargo.lock at line 673 [17.12201]

∅:D[18.29899] → [2.22165:22315]

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

[18.29899]

[16.10901]

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

Replacement in Cargo.lock at line 676 [17.12201]

∅:D[16.10971] → [2.22316:22392]

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

[16.10971]

[18.30195]

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

Replacement in Cargo.lock at line 678 [17.12201]

∅:D[18.30275] → [2.22393:22797]

 "openssl-sys 0.9.39 (registry+https://github.com/rust-lang/crates.io-index)",
 "schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)",

[18.30275]

[18.30679]

 "openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",
 "schannel 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "tempfile 3.0.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 690 [17.12201]

∅:D[18.30809] → [2.22798:23016]

 "cfg-if 0.1.6 (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)",

[18.30809]

[18.31027]

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 697 [17.12201]
∅:D[18.31073] → [2.23017:23035]
```
version = "1.0.1"
```
[18.31073]
[18.31091]
```
version = "1.0.3"
```

Deletion in Cargo.lock at line 699 [17.12201]

∅:D[18.31156] → [2.23036:23133]

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

Replacement in Cargo.lock at line 720 [17.12201]
∅:D[18.31727] → [2.23134:23152]
```
version = "1.8.0"
```
[18.31727]
[18.31745]
```
version = "1.10.0"
```

Replacement in Cargo.lock at line 723 [17.12201]

∅:D[18.31827] → [2.23153:23225]

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

[18.31827]

[18.31899]

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

Insertion in Cargo.lock at line 725 [17.12201]

[18.31901]

[3.39281]


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

Replacement in Cargo.lock at line 733 [17.12201]
∅:D[18.31931] → [2.23226:23246]
```
version = "0.10.15"
```
[18.31931]
[18.31951]
```
version = "0.10.20"
```

Replacement in Cargo.lock at line 737 [17.12201]

∅:D[18.32108] → [2.23247:23320]

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

[18.32108]

[18.32181]

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 739 [17.12201]

∅:D[18.32261] → [2.23321:23550]

 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",

[18.32261]

[18.32490]

 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 751 [17.12201]
∅:D[18.32645] → [2.23551:23570]
```
version = "0.9.39"
```
[18.32645]
[18.32664]
```
version = "0.9.43"
```

Replacement in Cargo.lock at line 754 [17.12201]

∅:D[18.32746] → [2.23571:23713]

 "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)",

[18.32746]

[18.32888]

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

Insertion in Cargo.lock at line 757 [17.12201]

[18.32966]

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

Replacement in Cargo.lock at line 771 [17.12201]
∅:D[18.33294] → [2.23714:23732]
```
version = "0.6.4"
```
[18.33294]
[18.33312]
```
version = "0.7.1"
```

Replacement in Cargo.lock at line 775 [17.12201]

∅:D[16.11532] → [2.23733:23816]

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

[16.11532]

[18.33552]

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

Replacement in Cargo.lock at line 780 [17.12201]
∅:D[18.33593] → [2.23817:23835]
```
version = "0.3.1"
```
[18.33593]
[18.33611]
```
version = "0.4.0"
```

Replacement in Cargo.lock at line 783 [17.12201]

∅:D[18.33693] → [2.23836:23979]

 "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)",

[18.33693]

[18.33836]

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

Replacement in Cargo.lock at line 786 [17.12201]

∅:D[18.33916] → [2.23980:24128]

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

[18.33916]

[3.40242]

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

Replacement in Cargo.lock at line 806 [17.12201]
∅:D[18.34214] → [2.24129:24148]
```
version = "0.7.23"
```
[18.34214]
[18.34233]
```
version = "0.7.24"
```

Replacement in Cargo.lock at line 809 [17.12201]

∅:D[18.34315] → [2.24149:24227]

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

[18.34315]

[18.34393]

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

Replacement in Cargo.lock at line 814 [17.12201]
∅:D[18.34429] → [2.24228:24247]
```
version = "0.7.23"
```
[18.34429]
[18.34448]
```
version = "0.7.24"
```

Replacement in Cargo.lock at line 817 [17.12201]

∅:D[18.34530] → [2.24248:24407]

 "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)",

[18.34530]

[18.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 [17.12201]
∅:D[18.34727] → [2.24408:24427]
```
version = "0.7.23"
```
[18.34727]
[18.34746]
```
version = "0.7.24"
```

Replacement in Cargo.lock at line 826 [17.12201]

∅:D[18.34828] → [2.24428:24577]

 "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)",

[18.34828]

[18.34977]

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

Replacement in Cargo.lock at line 832 [17.12201]
∅:D[18.35012] → [2.24578:24597]
```
version = "0.7.23"
```
[18.35012]
[18.35031]
```
version = "0.7.24"
```
Replacement in Cargo.lock at line 850 [17.12201]
∅:D[18.35464] → [2.24598:24617]
```
version = "0.4.24"
```
[18.35464]
[18.35483]
```
version = "0.4.27"
```
Replacement in Cargo.lock at line 863 [17.12201]
∅:D[18.35794] → [2.24618:24637]
```
version = "0.12.4"
```
[18.35794]
[18.35813]
```
version = "0.13.3"
```

Replacement in Cargo.lock at line 866 [17.12201]

∅:D[18.35895] → [2.24638:24791]

 "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)",

[18.35895]

[16.11782]

 "encoding_rs 0.8.17 (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 [17.12201]

∅:D[16.11852] → [2.24792:24865]

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

[16.11852]

[18.36191]

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

Replacement in Cargo.lock at line 879 [17.12201]
∅:D[18.36333] → [2.24866:24885]
```
version = "0.6.10"
```
[18.36333]
[23.13435]
```
version = "0.6.12"
```

Replacement in Cargo.lock at line 882 [17.12201]

∅:D[23.13517] → [2.24886:24965]

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

[23.13517]

[2.24965]

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

Replacement in Cargo.lock at line 887 [17.12201]
∅:D[2.24994] → [2.24994:25012]
```
version = "0.4.3"
```
[2.24994]
[2.25012]
```
version = "0.5.6"
```
Deletion in Cargo.lock at line 890 [17.12201]
∅:D[2.25094] → [2.25094:25320]
∅:D[21.29702] → [18.37374:37377]
∅:D[2.25320] → [18.37374:37377]
∅:D[22.23333] → [18.37374:37377]
∅:D[23.13743] → [18.37374:37377]
∅:D[18.37374] → [18.37374:37377]
∅:D[18.37377] → [25.9029:9041]
∅:D[25.9029] → [25.9029:9041]
∅:D[25.9041] → [18.37378:37392]
∅:D[18.37392] → [2.25321:25339]
∅:D[26.23510] → [18.37410:37492]
∅:D[21.29721] → [18.37410:37492]
∅:D[20.11994] → [18.37410:37492]
∅:D[2.25339] → [18.37410:37492]
∅:D[3.41186] → [18.37410:37492]
∅:D[27.17174] → [18.37410:37492]
∅:D[18.37410] → [18.37410:37492]
```
 "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"
version = "0.5.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
```

Replacement in Cargo.lock at line 891 [17.12201]

∅:D[20.12070] → [2.25340:25642]

 "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_core 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[20.12070]

[16.12245]

 "fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 899 [17.12201]
∅:D[16.12274] → [2.25643:25661]
```
version = "0.6.1"
```
[16.12274]
[16.12292]
```
version = "0.6.5"
```

Replacement in Cargo.lock at line 902 [17.12201]

∅:D[16.12374] → [2.25662:26044]

 "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)",
 "rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",

[16.12374]

[16.12756]

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

Replacement in Cargo.lock at line 908 [17.12201]

∅:D[16.12907] → [2.26045:26353]

 "rand_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[16.12907]

[16.13143]

 "rand_jitter 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 917 [17.12201]
∅:D[16.13179] → [2.26354:26372]
```
version = "0.1.0"
```
[16.13179]
[16.13197]
```
version = "0.1.1"
```

Replacement in Cargo.lock at line 920 [17.12201]

∅:D[16.13279] → [2.26373:26529]

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

[16.13279]

[18.38333]

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

Replacement in Cargo.lock at line 926 [17.12201]
∅:D[18.38659] → [2.26530:26548]
```
version = "0.2.2"
```
[18.38659]
[18.38677]
```
version = "0.3.1"
```

Replacement in Cargo.lock at line 929 [17.12201]

∅:D[18.38759] → [2.26549:26625]

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

[18.38759]

[18.38835]

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

Replacement in Cargo.lock at line 934 [17.12201]
∅:D[18.38869] → [2.26626:26644]
```
version = "0.3.0"
```
[18.38869]
[16.13436]
```
version = "0.4.0"
```

Replacement in Cargo.lock at line 942 [17.12201]

∅:D[16.13631] → [2.26645:26721]

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

[16.13631]

[16.13707]

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

Replacement in Cargo.lock at line 950 [17.12201]

∅:D[16.13778] → [2.26722:26798]

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

[16.13778]

[21.30943]

 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_jitter"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_os"
version = "0.1.3"
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-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.4.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.7 (registry+https://github.com/rust-lang/crates.io-index)",

Insertion in Cargo.lock at line 978 [17.12201]

[16.13875]

[2.26799]

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

Replacement in Cargo.lock at line 990 [17.12201]

∅:D[16.13975] → [2.26818:26974]

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

[16.13975]

[16.14131]

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

Replacement in Cargo.lock at line 994 [17.12201]
∅:D[16.14146] → [16.14146:14169]
∅:D[16.14146] → [16.14146:14169]
∅:D[16.14146] → [16.14146:14169]
∅:D[16.14146] → [16.14146:14169]
∅:D[16.14146] → [16.14146:14169]
∅:D[16.14146] → [16.14146:14169]
∅:D[16.14146] → [16.14146:14169]
∅:D[16.14169] → [2.26975:26993]
```
name = "rand_xorshift"
version = "0.1.0"
```
[16.14146]
[21.31977]
```
name = "rdrand"
version = "0.4.0"
```

Replacement in Cargo.lock at line 998 [17.12201]

∅:D[21.32059] → [2.26994:27070]

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

[21.32059]

[21.32135]

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

Replacement in Cargo.lock at line 1003 [17.12201]
∅:D[18.39910] → [2.27071:27090]
```
version = "0.1.43"
```
[18.39910]
[18.39929]
```
version = "0.1.54"
```

Replacement in Cargo.lock at line 1011 [17.12201]

∅:D[16.14463] → [2.27091:27172]

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

[16.14463]

[16.14544]

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

Replacement in Cargo.lock at line 1016 [17.12201]
∅:D[16.14574] → [2.27173:27191]
```
version = "1.0.6"
```
[16.14574]
[16.14592]
```
version = "1.1.5"
```

Replacement in Cargo.lock at line 1019 [17.12201]

∅:D[16.14674] → [2.27192:27423]

 "aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",

[16.14674]

[16.14905]

 "aho-corasick 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1028 [17.12201]
∅:D[16.15099] → [2.27424:27442]
```
version = "0.6.3"
```
[16.15099]
[18.40259]
```
version = "0.6.6"
```

Replacement in Cargo.lock at line 1039 [17.12201]

∅:D[18.41080] → [2.27443:27516]

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

[18.41080]

[18.41153]

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

Replacement in Cargo.lock at line 1044 [17.12201]
∅:D[18.41189] → [2.27517:27535]
```
version = "0.6.1"
```
[18.41189]
[18.41207]
```
version = "0.6.2"
```
Replacement in Cargo.lock at line 1053 [17.12201]
∅:D[18.41481] → [2.27536:27554]
```
version = "0.1.9"
```
[18.41481]
[18.41499]
```
version = "0.1.14"
```

Deletion in Cargo.lock at line 1067 [17.12201]

∅:D[16.15212] → [2.27555:27668]

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

Replacement in Cargo.lock at line 1071 [17.12201]
∅:D[18.42024] → [2.27669:27687]
```
version = "0.4.2"
```
[18.42024]
[18.42042]
```
version = "0.4.3"
```

Replacement in Cargo.lock at line 1074 [17.12201]

∅:D[18.42124] → [2.27688:27837]

 "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)",

[18.42124]

[18.42273]

 "base64 0.10.1 (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.3 (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 1084 [17.12201]
∅:D[18.42306] → [2.27838:27857]
```
version = "0.1.14"
```
[18.42306]
[18.42325]
```
version = "0.1.15"
```

Replacement in Cargo.lock at line 1087 [17.12201]

∅:D[18.42407] → [2.27858:28009]

 "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[18.42407]

[18.42558]

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

Replacement in Cargo.lock at line 1098 [17.12201]
∅:D[18.42717] → [2.28010:28028]
```
version = "0.2.1"
```
[18.42717]
[18.42735]
```
version = "0.2.2"
```

Replacement in Cargo.lock at line 1103 [17.12201]

∅:D[18.42985] → [2.28029:28190]

 "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)",

[18.42985]

[18.43146]

 "libc 0.2.51 (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 1109 [17.12201]
∅:D[18.43193] → [2.28191:28209]
```
version = "0.2.1"
```
[18.43193]
[18.43211]
```
version = "0.2.3"
```

Insertion in Cargo.lock at line 1112 [17.12201]

[18.43293]

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

Replacement in Cargo.lock at line 1114 [17.12201]

∅:D[18.43379] → [2.28210:28282]

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

[18.43379]

[18.43451]

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

Replacement in Cargo.lock at line 1134 [17.12201]

∅:D[18.43832] → [2.28283:28580]

 "clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",

[18.43832]

[16.15663]

 "clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1139 [17.12201]

∅:D[16.15733] → [2.28581:28881]

 "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)",

[16.15733]

[16.15881]

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

Replacement in Cargo.lock at line 1145 [17.12201]

∅:D[16.16040] → [2.28882:29186]

 "tokio-xmpp 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)",

[16.16040]

[18.44887]

 "tokio-xmpp 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1152 [17.12201]
∅:D[18.44917] → [2.29187:29206]
```
version = "1.0.80"
```
[18.44917]
[18.44936]
```
version = "1.0.90"
```
Replacement in Cargo.lock at line 1157 [17.12201]
∅:D[18.45036] → [2.29207:29226]
```
version = "1.0.80"
```
[18.45036]
[18.45055]
```
version = "1.0.90"
```

Replacement in Cargo.lock at line 1160 [17.12201]

∅:D[18.45137] → [2.29227:29451]

 "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)",

[18.45137]

[18.45361]

 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1167 [17.12201]
∅:D[18.45396] → [2.29452:29471]
```
version = "1.0.33"
```
[18.45396]
[18.45415]
```
version = "1.0.39"
```

Replacement in Cargo.lock at line 1172 [17.12201]

∅:D[16.16584] → [2.29472:29545]

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

[16.16584]

[18.45711]

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

Replacement in Cargo.lock at line 1177 [17.12201]
∅:D[18.45741] → [2.29546:29564]
```
version = "0.7.0"
```
[18.45741]
[18.45759]
```
version = "0.8.1"
```

Replacement in Cargo.lock at line 1180 [17.12201]

∅:D[18.45841] → [2.29565:29794]

 "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)",

[18.45841]

[18.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 1183 [17.12201]

[18.46146]

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

Replacement in Cargo.lock at line 1188 [17.12201]
∅:D[18.46175] → [2.29795:29813]
```
version = "0.7.1"
```
[18.46175]
[18.46193]
```
version = "0.8.0"
```

Replacement in Cargo.lock at line 1191 [17.12201]

∅:D[18.46275] → [2.29814:30043]

 "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)",

[18.46275]

[18.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 1194 [17.12201]

[18.46580]

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

Replacement in Cargo.lock at line 1199 [17.12201]
∅:D[18.46609] → [2.30044:30062]
```
version = "0.7.3"
```
[18.46609]
[18.46627]
```
version = "0.8.1"
```

Replacement in Cargo.lock at line 1202 [17.12201]

∅:D[18.46709] → [2.30063:30292]

 "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)",

[18.46709]

[18.46938]

 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.3.1 (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 1206 [17.12201]

[18.47011]

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

Replacement in Cargo.lock at line 1211 [17.12201]
∅:D[18.47047] → [2.30293:30311]
```
version = "0.1.6"
```
[18.47047]
[18.47065]
```
version = "0.1.8"
```

Replacement in Cargo.lock at line 1214 [17.12201]

∅:D[18.47147] → [2.30312:30459]

 "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)",

[18.47147]

[18.47294]

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

Replacement in Cargo.lock at line 1225 [17.12201]
∅:D[18.47438] → [2.30460:30478]
```
version = "0.4.1"
```
[18.47438]
[18.47456]
```
version = "0.4.2"
```
Replacement in Cargo.lock at line 1230 [17.12201]
∅:D[18.47552] → [2.30479:30497]
```
version = "0.6.6"
```
[18.47552]
[18.47570]
```
version = "0.6.9"
```

Deletion in Cargo.lock at line 1232 [17.12201]

∅:D[18.47635] → [2.30498:30595]

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

Replacement in Cargo.lock at line 1238 [17.12201]

∅:D[18.47862] → [2.30596:30895]

 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[18.47862]

[18.48161]

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1251 [17.12201]
∅:D[18.48316] → [2.30896:30914]
```
version = "0.1.2"
```
[18.48316]
[18.48334]
```
version = "0.1.3"
```

Replacement in Cargo.lock at line 1259 [17.12201]

∅:D[18.48534] → [2.30915:31159]

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

[18.48534]

[18.48778]

 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.3 (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 1263 [17.12201]

∅:D[18.48861] → [2.31160:31233]

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

[18.48861]

[18.48934]

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

Replacement in Cargo.lock at line 1273 [17.12201]

∅:D[18.49252] → [2.31234:31545]

 "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)",

[18.49252]

[18.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.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1287 [17.12201]

∅:D[18.49805] → [2.31546:31564]

version = "0.7.0"

[18.49805]

[18.49823]

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

Replacement in Cargo.lock at line 1307 [17.12201]
∅:D[18.50268] → [2.31565:31585]
```
version = "0.15.22"
```
[18.50268]
[18.50288]
```
version = "0.15.30"
```

Replacement in Cargo.lock at line 1310 [17.12201]

∅:D[18.50370] → [2.31586:31738]

 "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)",

[18.50370]

[18.50522]

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

Replacement in Cargo.lock at line 1328 [17.12201]

∅:D[18.50947] → [2.31739:31963]

 "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)",

[18.50947]

[18.51171]

 "proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1336 [17.12201]
∅:D[18.51282] → [2.31964:31982]
```
version = "3.0.5"
```
[18.51282]
[18.51300]
```
version = "3.0.7"
```

Replacement in Cargo.lock at line 1339 [17.12201]

∅:D[18.51382] → [2.31983:32280]

 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",

[18.51382]

[18.51679]

 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1344 [17.12201]

∅:D[18.51760] → [2.32281:32354]

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

[18.51760]

[18.51833]

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

Replacement in Cargo.lock at line 1349 [17.12201]
∅:D[18.51865] → [2.32355:32373]
```
version = "0.4.0"
```
[18.51865]
[18.51883]
```
version = "0.4.1"
```

Replacement in Cargo.lock at line 1354 [17.12201]

∅:D[18.52106] → [2.32374:32446]

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

[18.52106]

[16.17839]

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

Replacement in Cargo.lock at line 1370 [17.12201]

∅:D[18.52519] → [2.32447:32600]

 "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)",

[18.52519]

[18.52672]

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

Replacement in Cargo.lock at line 1377 [17.12201]
∅:D[18.52785] → [2.32601:32620]
```
version = "0.10.0"
```
[18.52785]
[18.52804]
```
version = "0.11.0"
```

Replacement in Cargo.lock at line 1388 [17.12201]

∅:D[16.18340] → [2.32621:32699]

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

[16.18340]

[18.52966]

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

Replacement in Cargo.lock at line 1393 [17.12201]
∅:D[18.53210] → [2.32700:32719]
```
version = "0.1.40"
```
[18.53210]
[18.53229]
```
version = "0.1.42"
```

Replacement in Cargo.lock at line 1396 [17.12201]

∅:D[18.53311] → [2.32720:32946]

 "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)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[18.53311]

[18.53537]

 "libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1403 [17.12201]
∅:D[18.53567] → [2.32947:32966]
```
version = "0.1.13"
```
[18.53567]
[18.53586]
```
version = "0.1.18"
```

Replacement in Cargo.lock at line 1406 [17.12201]

∅:D[18.53668] → [2.32967:33115]

 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

[18.53668]

[18.53816]

 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1409 [17.12201]

∅:D[18.53887] → [2.33116:33191]

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

[18.53887]

[18.53962]

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

Replacement in Cargo.lock at line 1411 [17.12201]

∅:D[18.54040] → [2.33192:33828]

 "tokio-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",

[18.54040]

[16.19073]

 "tokio-current-thread 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-fs 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.4 (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.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1422 [17.12201]

∅:D[16.19149] → [2.33829:33905]

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

[16.19149]

[16.19225]

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

Replacement in Cargo.lock at line 1430 [17.12201]

∅:D[16.19363] → [2.33906:33981]

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

[16.19363]

[18.55024]

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

Replacement in Cargo.lock at line 1438 [17.12201]

∅:D[18.55160] → [2.33982:34206]

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

[18.55160]

[18.55384]

 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1445 [17.12201]
∅:D[18.55429] → [2.34207:34225]
```
version = "0.1.4"
```
[18.55429]
[18.55447]
```
version = "0.1.6"
```

Replacement in Cargo.lock at line 1448 [17.12201]

∅:D[18.55529] → [2.34226:34382]

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

[18.55529]

[18.55685]

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

Replacement in Cargo.lock at line 1454 [17.12201]
∅:D[18.55724] → [2.34383:34401]
```
version = "0.1.5"
```
[18.55724]
[18.55742]
```
version = "0.1.7"
```

Replacement in Cargo.lock at line 1457 [17.12201]

∅:D[18.55824] → [2.34402:34477]

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

[18.55824]

[18.55899]

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

Replacement in Cargo.lock at line 1463 [17.12201]
∅:D[18.55932] → [2.34478:34496]
```
version = "0.1.4"
```
[18.55932]
[18.55950]
```
version = "0.1.6"
```

Replacement in Cargo.lock at line 1466 [17.12201]

∅:D[18.56032] → [2.34497:34731]

 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",

[18.56032]

[18.56266]

 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1473 [17.12201]
∅:D[18.56299] → [2.34732:34751]
```
version = "0.1.10"
```
[18.56299]
[18.56318]
```
version = "0.1.12"
```

Replacement in Cargo.lock at line 1476 [17.12201]

∅:D[18.56400] → [2.34752:34900]

 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

[18.56400]

[16.19690]

 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1483 [17.12201]
∅:D[18.56656] → [2.34901:34919]
```
version = "0.1.7"
```
[18.56656]
[18.56674]
```
version = "0.1.9"
```

Replacement in Cargo.lock at line 1486 [17.12201]

∅:D[18.56756] → [2.34920:35155]

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

[18.56756]

[16.19941]

 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1491 [17.12201]

∅:D[18.57132] → [2.35156:35537]

 "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)",

[18.57132]

[18.57513]

 "num_cpus 1.10.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.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1504 [17.12201]

∅:D[18.57650] → [2.35538:35685]

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

[18.57650]

[18.57797]

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

Replacement in Cargo.lock at line 1508 [17.12201]

∅:D[18.57942] → [2.35686:36074]

 "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)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",

[18.57942]

[21.39434]

 "signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-sync"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1526 [17.12201]
∅:D[18.58364] → [2.36075:36093]
```
version = "0.1.2"
```
[18.58364]
[18.58382]
```
version = "0.1.3"
```

Replacement in Cargo.lock at line 1529 [17.12201]

∅:D[18.58464] → [2.36094:36242]

 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

[18.58464]

[18.58612]

 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1533 [17.12201]

∅:D[18.58755] → [2.36243:36399]

 "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)",

[18.58755]

[18.58911]

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

Replacement in Cargo.lock at line 1539 [17.12201]
∅:D[18.58952] → [2.36400:36418]
```
version = "0.1.9"
```
[18.58952]
[18.58970]
```
version = "0.1.13"
```

Replacement in Cargo.lock at line 1542 [17.12201]

∅:D[18.59052] → [2.36419:36658]

 "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)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

[18.59052]

[16.20603]

 "crossbeam-deque 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-queue 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1547 [17.12201]

∅:D[16.20673] → [2.36659:36886]

 "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)",

[16.20673]

[18.59588]

 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand 0.6.5 (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.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1555 [17.12201]
∅:D[18.59624] → [2.36887:36905]
```
version = "0.2.8"
```
[18.59624]
[18.59642]
```
version = "0.2.10"
```

Replacement in Cargo.lock at line 1558 [17.12201]

∅:D[18.59724] → [2.36906:37215]

 "crossbeam-utils 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (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)",

[18.59724]

[18.60033]

 "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (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.7 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1566 [17.12201]
∅:D[18.60067] → [2.37216:37234]
```
version = "0.2.0"
```
[18.60067]
[18.60085]
```
version = "0.2.1"
```

Replacement in Cargo.lock at line 1569 [17.12201]

∅:D[18.60167] → [2.37235:37310]

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

[18.60167]

[18.60242]

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

Replacement in Cargo.lock at line 1571 [17.12201]

∅:D[18.60319] → [2.37311:37387]

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

[18.60319]

[18.60395]

 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-trace-core"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1587 [17.12201]

∅:D[18.60529] → [2.37388:37536]

 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

[18.60529]

[16.20941]

 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1592 [17.12201]

∅:D[18.60896] → [2.37537:37693]

 "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)",

[18.60896]

[18.61052]

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

Replacement in Cargo.lock at line 1598 [17.12201]
∅:D[18.61086] → [2.37694:37712]
```
version = "0.2.4"
```
[18.61086]
[18.61104]
```
version = "0.2.5"
```

Replacement in Cargo.lock at line 1601 [17.12201]

∅:D[18.61186] → [2.37713:37861]

 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

[18.61186]

[18.61334]

 "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1604 [17.12201]

∅:D[18.61406] → [2.37862:37934]

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

[18.61406]

[16.21258]

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

Replacement in Cargo.lock at line 1609 [17.12201]

∅:D[16.21407] → [2.37935:38091]

 "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)",

[16.21407]

[18.61927]

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

Replacement in Cargo.lock at line 1615 [17.12201]
∅:D[18.61962] → [2.38092:38110]
```
version = "0.2.0"
```
[18.61962]
[18.61980]
```
version = "1.0.0"
```

Replacement in Cargo.lock at line 1618 [17.12201]

∅:D[18.62062] → [2.38111:38184]

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

[18.62062]

[18.62135]

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

Replacement in Cargo.lock at line 1620 [17.12201]

∅:D[18.62214] → [2.38185:38260]

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

[18.62214]

[18.62289]

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

Deletion in Cargo.lock at line 1622 [17.12201]

∅:D[18.62360] → [2.38261:38405]

 "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 1623 [17.12201]

∅:D[18.62581] → [2.38406:38627]

 "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)",

[18.62581]

[18.62802]

 "quick-xml 0.13.3 (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.18 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1627 [17.12201]

∅:D[18.62880] → [2.38628:39022]

 "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)",

[18.62880]

[16.21637]

 "tokio-io 0.1.12 (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.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-resolver 0.10.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1632 [17.12201]

∅:D[16.21713] → [2.39023:39103]

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

[16.21713]

[18.63430]

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

Replacement in Cargo.lock at line 1637 [17.12201]
∅:D[18.63459] → [2.39104:39123]
```
version = "0.4.10"
```
[18.63459]
[18.63478]
```
version = "0.5.0"
```

Replacement in Cargo.lock at line 1640 [17.12201]

∅:D[18.63560] → [2.39124:39197]

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

[18.63560]

[18.63633]

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

Replacement in Cargo.lock at line 1645 [17.12201]
∅:D[18.63673] → [2.39198:39216]
```
version = "0.4.3"
```
[18.63673]
[18.63691]
```
version = "0.6.3"
```

Replacement in Cargo.lock at line 1648 [17.12201]

∅:D[18.63773] → [2.39217:39447]

 "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)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",

[18.63773]

[18.64003]

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

Replacement in Cargo.lock at line 1652 [17.12201]

∅:D[18.64074] → [2.39448:39526]

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

[18.64074]

[16.21812]

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

Replacement in Cargo.lock at line 1654 [17.12201]

∅:D[16.21882] → [2.39527:39673]

 "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)",

[16.21882]

[18.64368]

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

Replacement in Cargo.lock at line 1657 [17.12201]

∅:D[18.64442] → [2.39674:40065]

 "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-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",

[18.64442]

[16.22118]

 "tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1668 [17.12201]
∅:D[18.65022] → [2.40066:40084]
```
version = "0.9.1"
```
[18.65022]
[18.65040]
```
version = "0.10.3"
```

Replacement in Cargo.lock at line 1671 [17.12201]

∅:D[18.65122] → [2.40085:40312]

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

[18.65122]

[16.22265]

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

Replacement in Cargo.lock at line 1675 [17.12201]

∅:D[16.22340] → [2.40313:40391]

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

[16.22340]

[16.22418]

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

Replacement in Cargo.lock at line 1677 [17.12201]

∅:D[16.22488] → [2.40392:40776]

 "lru-cache 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",

[16.22488]

[18.65956]

 "lru-cache 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "resolv-conf 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",

Replacement in Cargo.lock at line 1691 [17.12201]
∅:D[18.66103] → [2.40777:40795]
```
version = "0.2.2"
```
[18.66103]
[18.66121]
```
version = "0.3.2"
```

Insertion in Cargo.lock at line 1693 [17.12201]

[18.66186]

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

Replacement in Cargo.lock at line 1717 [17.12201]
∅:D[18.66669] → [2.40796:40814]
```
version = "0.1.7"
```
[18.66669]
[18.66687]
```
version = "0.1.8"
```

Insertion in Cargo.lock at line 1719 [17.12201]

[18.66752]

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

Deletion in Cargo.lock at line 1739 [17.12201]

∅:D[30.7115] → [2.40815:41022]

name = "unreachable"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]

Replacement in Cargo.lock at line 1750 [17.12201]
∅:D[18.67696] → [2.41023:41041]
```
version = "0.7.4"
```
[18.67696]
[16.22772]
```
version = "0.7.5"
```

Deletion in Cargo.lock at line 1766 [17.12201]

∅:D[18.68055] → [2.41042:41271]

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

Replacement in Cargo.lock at line 1773 [17.12201]

∅:D[18.68476] → [2.41272:41347]

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

[18.68476]

[16.22890]

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

Replacement in Cargo.lock at line 1790 [17.12201]
∅:D[18.68955] → [2.41348:41366]
```
version = "0.3.6"
```
[18.68955]
[18.68973]
```
version = "0.3.7"
```
Replacement in Cargo.lock at line 1809 [17.12201]
∅:D[16.22982] → [2.41367:41385]
```
version = "0.1.1"
```
[16.22982]
[16.23000]
```
version = "0.1.2"
```

Replacement in Cargo.lock at line 1812 [17.12201]

∅:D[16.23082] → [2.41386:41459]

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

[16.23082]

[16.23155]

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

Replacement in Cargo.lock at line 1825 [17.12201]

∅:D[16.23303] → [2.41460:41611]

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

[16.23303]

[16.23454]

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

Replacement in Cargo.lock at line 1834 [17.12201]

∅:D[18.70251] → [2.41612:41685]

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

[18.70251]

[18.70324]

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

Replacement in Cargo.lock at line 1842 [17.12201]

∅:D[18.70456] → [2.41686:41759]

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

[18.70456]

[18.70529]

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

Replacement in Cargo.lock at line 1861 [17.12201]

∅:D[18.71090] → [2.41760:41910]

 "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)",

[18.71090]

[10.31448]

 "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 1867 [17.12201]
∅:D[10.31485] → [2.41911:41930]
```
version = "0.11.1"
```
[10.31485]
[10.31504]
```
version = "0.12.2"
```

Replacement in Cargo.lock at line 1870 [17.12201]

∅:D[10.31586] → [2.41931:42077]

 "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.31586]

[10.31733]

 "base64 0.10.1 (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 1873 [17.12201]

∅:D[10.31806] → [2.42078:42584]

 "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.31806]

[18.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)",
]
[[package]]
name = "xmpp-parsers"
version = "0.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "blake2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",

Replacement in Cargo.lock at line 1899 [17.12201]

∅:D[18.72117] → [2.42585:42740]

"checksum aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "1e9a933f4e58658d7b12defcf96dc5c720f20832deebe3e0a19efd3b6aaeeb9e"

[18.72117]

[18.72272]

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

Replacement in Cargo.lock at line 1902 [17.12201]

∅:D[18.72425] → [2.42741:43194]

"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"

[18.72425]

[18.72878]

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

Replacement in Cargo.lock at line 1905 [17.12201]

∅:D[18.73026] → [2.43195:43805]

"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"

[18.73026]

[18.73636]

"checksum autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a6d640bee2da49f60a4068a7fae53acde8982514ab7bae8b8cea9e88cbcfd799"
"checksum backtrace 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "f106c02a3604afcdc0df5d36cc47b44b55917dbaf3d808f71c163a0ddba64637"
"checksum backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)" = "797c830ac25ccc92a7f8a7b9862bde440715531514594a6154e3d4a54dd769b6"
"checksum base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0b25d992356d2eb0ed82172f5248873db5560c4721f564b13cb5193bda5e668e"

Replacement in Cargo.lock at line 1910 [17.12201]

∅:D[18.73787] → [2.43806:44564]

"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"
"checksum bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "40ade3d27603c2cb345eb0912aec461a6dec7e06a4ae48589904e808335c7afa"

[18.73787]

[18.74545]

"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.3 (registry+https://github.com/rust-lang/crates.io-index)" = "d75255892aeb580d3c566f213a2b6fdc1c66667839f45719ee1d30ebf2aea591"
"checksum byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
"checksum byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a019b10a2a7cdeb292db131fc8113e57ea2a908f6e7894b0c3c671893b65dbeb"
"checksum bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)" = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c"

Replacement in Cargo.lock at line 1917 [17.12201]

∅:D[18.74692] → [2.44565:44860]

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

[18.74692]

[18.74987]

"checksum cc 1.0.35 (registry+https://github.com/rust-lang/crates.io-index)" = "5e5f3fee5eeb60324c2781f1e41286bdee933850fff9b3c672587fed5ec58c83"
"checksum cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "11d43355396e872eefb45ce6342e4374ed7bc2b3a502d1b28e36d6e23c05d1f4"

Replacement in Cargo.lock at line 1920 [17.12201]

∅:D[18.75136] → [2.44861:45009]

"checksum clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b957d88f4b6a63b9d70d5f454ac8011819c6efa7727858f458ab71c756ce2d3e"

[18.75136]

[18.75284]

"checksum clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5067f5bb2d80ef5d68b4c87db81601f0b75bca627bc2ef76b141d7b846a3c6d9"

Deletion in Cargo.lock at line 1922 [17.12201]

∅:D[18.75435] → [2.45010:45169]

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

Replacement in Cargo.lock at line 1924 [17.12201]

∅:D[18.75914] → [2.45170:45951]

"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"

[18.75914]

[18.76695]

"checksum crossbeam-deque 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b18cd2e169ad86297e6bc0ad9aa679aee9daa4f19e8163860faf7c164e4f5a71"
"checksum crossbeam-epoch 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "04c9e3102cc2d69cd681412141b390abd55a362afc1540965dad0ad4d34280b4"
"checksum crossbeam-queue 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7c979cd6cfe72335896575c6b5688da489e420d36a27a0b9eb0c73db574b4a4b"
"checksum crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "f8306fcef4a7b563b76b7dd949ca48f52bc1141aa067d2ea09565f3e2652aa5c"
"checksum crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4434400df11d95d556bac068ddfedd482915eb18fe8bea89bc80b6e4b1c179e5"

Replacement in Cargo.lock at line 1930 [17.12201]

∅:D[18.76850] → [2.45952:46564]

"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"
"checksum env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "afb070faf94c85d17d50ca44f6ad076bce18ae92f0037d350947240a36e9d42e"
"checksum error-chain 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faa976b4fd2e4c2b2f3f486874b19e61944d3de3de8b61c9fcf835d583871bcc"

[18.76850]

[18.77462]

"checksum digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "05f47366984d3ad862010e22c7ce81a7dbcaebbdfb37241a620f8b6596ee135c"
"checksum encoding_rs 0.8.17 (registry+https://github.com/rust-lang/crates.io-index)" = "4155785c79f2f6701f185eb2e6b4caf0555ec03477cb4c70db67b465311620ed"
"checksum env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b61fa891024a945da30a9581546e8cfaf5602c7b3f4c137a2805cf388f92075a"

Replacement in Cargo.lock at line 1934 [17.12201]

∅:D[18.77616] → [2.46565:46872]

"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"

[18.77616]

[18.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"

Insertion in Cargo.lock at line 1940 [17.12201]

[18.78540]

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

Replacement in Cargo.lock at line 1944 [17.12201]

∅:D[18.79005] → [2.46873:47024]

"checksum futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)" = "49e7653e374fe0d0c12de4250f0bdb60680b8c80eed558c5c7538eec9c89e21b"

[18.79005]

[18.79156]

"checksum futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)" = "62941eff9507c8177d448bd83a44d9b9760856e184081d8cd79ba9f03dd24981"

Replacement in Cargo.lock at line 1946 [17.12201]

∅:D[18.79314] → [2.47025:47327]

"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"

[18.79314]

[18.79616]

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

Replacement in Cargo.lock at line 1950 [17.12201]

∅:D[18.79767] → [2.47328:47476]

"checksum http 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "02096a6d2c55e63f7fcb800690e4f889a25f6ec342e3adb4594e293b625215ab"

[18.79767]

[18.79915]

"checksum http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)" = "eed324f0f0daf6ec10c474f150505af2c143f251722bf9dbd1261bd1f2ee2c1a"

Replacement in Cargo.lock at line 1953 [17.12201]

∅:D[16.25390] → [2.47477:47627]

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

[16.25390]

[18.80368]

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

Replacement in Cargo.lock at line 1959 [17.12201]

∅:D[18.81112] → [2.47628:47774]

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

[18.81112]

[18.81258]

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

Replacement in Cargo.lock at line 1962 [17.12201]

∅:D[18.81562] → [2.47775:47929]

"checksum lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a374c89b9db55895453a74c1e38861d9deec0b01b405a82516e9d5de4820dea1"

[18.81562]

[16.25847]

"checksum lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bc5729f27f159ddd61f4df6228e827e86643d4d3e7c32183cb30a1c08f604a14"

Replacement in Cargo.lock at line 1964 [17.12201]

∅:D[16.25998] → [2.47930:48236]

"checksum libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)" = "10923947f84a519a45c8fefb7dd1b3e8c08747993381adee176d7a82b4195311"
"checksum linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7860ec297f7008ff7a1e3382d7f7e1dcd69efc94751a2284bafc3d013c2aa939"

[16.25998]

[16.26147]

"checksum libc 0.2.51 (registry+https://github.com/rust-lang/crates.io-index)" = "bedcc7a809076656486ffe045abeeac163da1b558e963a31e29fbfbeba916917"
"checksum linked-hash-map 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "ae91b68aebc4ddb91978b11a1b02ddd8602a05ec19002801c5666000e05e0f83"

Replacement in Cargo.lock at line 1968 [17.12201]

∅:D[16.26444] → [2.48237:48389]

"checksum lru-cache 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4d06ff7ff06f729ce5f4e227876cb88d10bc59cd4ae1e09fbb2bde15c850dc21"

[16.26444]

[18.82622]

"checksum lru-cache 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c"

Replacement in Cargo.lock at line 1970 [17.12201]

∅:D[18.82768] → [2.48390:48544]

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

[18.82768]

[18.82922]

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

Replacement in Cargo.lock at line 1972 [17.12201]

∅:D[18.83072] → [2.48545:48694]

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

[18.83072]

[18.83221]

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

Replacement in Cargo.lock at line 1974 [17.12201]

∅:D[18.83373] → [2.48695:48845]

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

[18.83373]

[18.83523]

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

Replacement in Cargo.lock at line 1980 [17.12201]

∅:D[18.84268] → [2.48846:49010]

"checksum new_debug_unreachable 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0cdc457076c78ab54d5e0d6fa7c47981757f1e34dc39ff92787f217dede586c4"

[18.84268]

[16.26595]

"checksum new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f40f005c60db6e03bae699e414c58bf9aa7ea02a2d0b9bfbcf19286cc4c82b30"

Replacement in Cargo.lock at line 1984 [17.12201]

∅:D[18.84890] → [2.49011:49314]

"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"

[18.84890]

[18.85193]

"checksum num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1a23f0ed30a54abaa0c7e83b1d2d87ada7c3c23078d1d87815af3e3b6385fbba"
"checksum opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "93f5bb2e8e8dec81642920ccff6b61f1eb94fa3020c5a325c9851ff604152409"
"checksum openssl 0.10.20 (registry+https://github.com/rust-lang/crates.io-index)" = "5a0d6b781aac4ac1bd6cafe2a2f0ad8c16ae8e1dd5184822a16c50139f8838d9"

Replacement in Cargo.lock at line 1988 [17.12201]

∅:D[18.85349] → [2.49315:49470]

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

[18.85349]

[16.26746]

"checksum openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)" = "33c86834957dd5b915623e94f2f4ab2c70dd8f6b70679824155d5ae21dbd495d"

Replacement in Cargo.lock at line 1990 [17.12201]

∅:D[16.26899] → [2.49471:49784]

"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"

[16.26899]

[18.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 1994 [17.12201]

∅:D[18.86129] → [2.49785:50398]

"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"

[18.86129]

[18.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 2000 [17.12201]

∅:D[18.87055] → [2.50399:50554]

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

[18.87055]

[18.87210]

"checksum proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4d317f9caece796be1980837fd5cb3dfec5613ebdb04ad0956deea83ce168915"

Replacement in Cargo.lock at line 2002 [17.12201]

∅:D[18.87364] → [2.50555:50708]

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

[18.87364]

[18.87517]

"checksum quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)" = "22fcc48ecef4609b243e8c01ff4695d08ee0fc9d5bdbc54630e1a5fe8bb40953"

Replacement in Cargo.lock at line 2004 [17.12201]

∅:D[18.87666] → [2.50709:51757]

"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"
"checksum rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e464cd887e869cddcae8792a4ee31d23c7edd516700695608f5b98c67ee0131c"
"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"
"checksum rand_core 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1961a422c4d189dfb50ffa9320bf1f2a9bd54ecb92792fb9477f99a1045f3372"
"checksum rand_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0905b6b7079ec73b314d4c748701f6931eb79fd97c668caa3f1899b22b32c6db"

[18.87666]

[16.27508]

"checksum quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faf4799c5d274f3868a4aae320a0a182cbd2baee377b378f080e16a23e9d80db"
"checksum rand 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c618c47cd3ebd209790115ab837de41425723956ad3ce2e6a7f09890947cacb9"
"checksum rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "6d71dacdc3c88c1fde3885a3be3fbab9f35724e6ce99467f7d9c5026132184ca"
"checksum rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "556d3a1ca6600bfcbab7c7c91ccb085ac7fbbcd70e008a98742e7847f4f7bcef"
"checksum rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
"checksum rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d0e7a549d590831370895ab7ba4ea0c1b6b011d106b5ff2da6eee112615e6dc0"

Replacement in Cargo.lock at line 2012 [17.12201]

∅:D[16.27811] → [2.51758:52222]

"checksum rand_pcg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "086bd09a33c7044e56bb44d5bdde5a60e7f119a9e95b0775f545de759a32fe05"
"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"

[16.27811]

[18.89481]

"checksum rand_jitter 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b9ea758282efe12823e0d952ddb269d2e1897227e464919a554f2a03ef1b832"
"checksum rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071"
"checksum rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "abf9b09b01790cfe0364f52bf32995ea3c39f4d2dd011eac241d2914146d0b44"
"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.54 (registry+https://github.com/rust-lang/crates.io-index)" = "12229c14a0f65c4f1cb046a3b52047cdd9da1f4b30f8a39c5063c8bae515e252"

Replacement in Cargo.lock at line 2019 [17.12201]

∅:D[18.89637] → [2.52223:52526]

"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"

[18.89637]

[18.89940]

"checksum regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "559008764a17de49a3146b234641644ed37d118d1ef641a0bb573d146edc6ce0"
"checksum regex-syntax 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "dcfd8681eebe297b81d98498869d4aae052137651ad7b96822f09ceb690d0a96"

Replacement in Cargo.lock at line 2022 [17.12201]

∅:D[18.90097] → [2.52527:52838]

"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"

[18.90097]

[18.90408]

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

Replacement in Cargo.lock at line 2026 [17.12201]

∅:D[16.28726] → [2.52839:53288]

"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"
"checksum schannel 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "0e1a231dc10abf6749cfa5d7767f25888d484201accbd919b66ab5413c502d56"

[16.28726]

[18.91159]

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

Replacement in Cargo.lock at line 2029 [17.12201]

∅:D[18.91312] → [2.53289:53615]

"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"

[18.91312]

[18.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 2033 [17.12201]

∅:D[18.91943] → [2.53616:54671]

"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"

[18.91943]

[18.92998]

"checksum serde 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "aa5f7c20820475babd2c077c3ab5f8c77a31c15e16ea38687b4c02d3e48680f4"
"checksum serde_derive 1.0.90 (registry+https://github.com/rust-lang/crates.io-index)" = "58fc82bec244f168b23d1963b45c8bf5726e9a15a9d146a067f9081aeed2de79"
"checksum serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)" = "5a23aa71d4a4d43fdbfaac00eff68ba8a06a51759a89ac3304323e800c4dd40d"
"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.8 (registry+https://github.com/rust-lang/crates.io-index)" = "97a47ae722318beceb0294e6f3d601205a1e6abaa4437d9d33e3a212233e3021"

Replacement in Cargo.lock at line 2041 [17.12201]

∅:D[18.93150] → [2.54672:54970]

"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"

[18.93150]

[18.93448]

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

Replacement in Cargo.lock at line 2045 [17.12201]

∅:D[18.93759] → [2.54971:55120]

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

[18.93759]

[18.93908]

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

Replacement in Cargo.lock at line 2049 [17.12201]

∅:D[18.94388] → [2.55121:55270]

"checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550"

[18.94388]

[18.94537]

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

Replacement in Cargo.lock at line 2052 [17.12201]

∅:D[18.94685] → [2.55271:55419]

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

[18.94685]

[18.94833]

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

Replacement in Cargo.lock at line 2055 [17.12201]

∅:D[16.29644] → [2.55420:55721]

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

[16.29644]

[16.29796]

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

Replacement in Cargo.lock at line 2059 [17.12201]

∅:D[18.95741] → [2.55722:55874]

"checksum textwrap 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "307686869c93e71f94da64286f9a9524c0f308a9e1c87a583de8e9c9039ad3f6"

[18.95741]

[16.29949]

"checksum textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"

Replacement in Cargo.lock at line 2061 [17.12201]

∅:D[16.30104] → [2.55875:56172]

"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"

[16.30104]

[16.30254]

"checksum time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)" = "db8dcfca086c1143c9270ac42a2bbd8a7ee477b78ac8e45b19abfb0cbede4b6f"
"checksum tokio 0.1.18 (registry+https://github.com/rust-lang/crates.io-index)" = "65641e515a437b308ab131a82ce3042ff9795bef5d6c5a9be4eb24195c417fd9"

Replacement in Cargo.lock at line 2065 [17.12201]

∅:D[18.96655] → [2.56173:56952]

"checksum tokio-current-thread 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "331c8acc267855ec06eb0c94618dcbbfea45bed2d20b77252940095273fb58f6"
"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"

[18.96655]

[16.30731]

"checksum tokio-current-thread 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "d16217cad7f1b840c5a97dfb3c43b0c871fef423a6e8d2118c604e843662a443"
"checksum tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "83ea44c6c0773cc034771693711c35c677b4b5a4b21b9e7071704c54de7d555e"
"checksum tokio-fs 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "3fe6dc22b08d6993916647d108a1a7d15b9cd29c4f4496c62b92c45b5041b7af"
"checksum tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "5090db468dad16e1a7a54c8c67280c5e4b544f3d3e018f0b913b400261f85926"
"checksum tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "6af16bfac7e112bea8b0442542161bfc41cbfa4466b580bdda7d18cb88b911ce"

Replacement in Cargo.lock at line 2071 [17.12201]

∅:D[16.30886] → [2.56953:57570]

"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"
"checksum tokio-timer 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "4f37f0111d76cc5da132fe9bc0590b9b9cfd079bc7e75ac3846278430a299ff8"
"checksum tokio-tls 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e53fdbf3156f588be1676022fe794232b24922d426e8c14f4e46891c1e31c440"

[16.30886]

[16.31201]

"checksum tokio-sync 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "fda385df506bf7546e70872767f71e81640f1f251bdf2fd8eb81a0eaec5fe022"
"checksum tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1d14b10654be682ac43efee27401d792507e30fd8d26389e1da3b185de2e4119"
"checksum tokio-threadpool 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "ec5759cf26cf9659555f36c431b515e3d05f66831741c85b4b5d5dfb9cf1323c"
"checksum tokio-timer 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)" = "2910970404ba6fa78c5539126a9ae2045d62e3713041e447f695f41405a120c6"
"checksum tokio-tls 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "354b8cd83825b3c20217a9dc174d6a0c67441a2fae5c41bcb1ea6679f6ae0f7c"
"checksum tokio-trace-core 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "350c9edade9830dc185ae48ba45667a445ab59f6167ef6d0254ec9d2430d9dd3"

Replacement in Cargo.lock at line 2078 [17.12201]

∅:D[16.31353] → [2.57571:58343]

"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"
"checksum toml 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "758664fc71a3a69038656bee8b6be6477d2a6c315a6b81f7081f591bffa4111f"
"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"

[16.31353]

[18.99130]

"checksum tokio-uds 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "037ffc3ba0e12a0ab4aca92e5234e0dedeb48fddf6ccd260f1f150a36a9f2445"
"checksum tokio-xmpp 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "952074d50e2a9907e714d28bb988232cc2f8c64542d3a97822e6d6afdd7a105f"
"checksum toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "87c5890a989fa47ecdc7bcb4c63a77a82c18f306714104b1decfd722db17b39e"
"checksum trust-dns-proto 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "09144f0992b0870fa8d2972cc069cbf1e3c0fda64d1f3d45c4d68d0e0b52ad4e"
"checksum trust-dns-resolver 0.10.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8a9f877f7a1ad821ab350505e1f1b146a4960402991787191d6d8cab2ce2de2c"

Replacement in Cargo.lock at line 2084 [17.12201]

∅:D[18.99281] → [2.58344:58495]

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

[18.99281]

[18.99432]

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

Replacement in Cargo.lock at line 2088 [17.12201]

∅:D[18.99889] → [2.58496:58660]

"checksum unicode-normalization 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "6a0180bc61fc5a987082bfa111f4cc95c4caff7f9799f3e46df09163a937aa25"

[18.99889]

[18.100053]

"checksum unicode-normalization 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "141339a08b982d942be2ca06ff8b076563cbe223d1befd5450716790d44e2426"

Deletion in Cargo.lock at line 2092 [17.12201]

∅:D[18.100517] → [2.58661:58815]

"checksum unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"

Replacement in Cargo.lock at line 2093 [17.12201]

∅:D[16.31953] → [2.58816:58964]

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

[16.31953]

[16.31954]

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

Deletion in Cargo.lock at line 2097 [17.12201]

∅:D[18.101417] → [2.58965:59268]

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

Replacement in Cargo.lock at line 2100 [17.12201]

∅:D[18.102169] → [2.59269:59418]

"checksum winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "92c1eb33641e276cfa214a0522acad57be5c56b10cb348b3c5117db75f3ac4b0"

[18.102169]

[18.102318]

"checksum winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "f10e386af2b13e47c89e7236a7a14a086791a2b88ebad6df9bf42040195cf770"

Replacement in Cargo.lock at line 2103 [17.12201]

∅:D[18.102642] → [2.59419:59573]

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

[18.102642]

[18.102796]

"checksum winapi-util 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7168bab6e1daee33b4557efd0e95d5ca70a03706d39fa5f3fe7a236f584b03c9"

Replacement in Cargo.lock at line 2110 [17.12201]

∅:D[16.32568] → [2.59574:59730]

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

[16.32568]

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