O01eg/sendxmppd-rs - Change LL3D5CXKPWIGTQ7MFK4YXDGDZOKD6CU5WCIWV3FG6TPGQOGD75QAC

Staring using element processor

Created by O01eg on April 13, 2019

LL3D5CXKPWIGTQ7MFK4YXDGDZOKD6CU5WCIWV3FG6TPGQOGD75QAC

Dependencies

In channels

main

Change contents

Deletion in src/xmpp/stanzas.rs at line 3 [5.13]
∅:D[3.26] → [4.0:57]
∅:D[4.57] → [2.0:30]
```
use xmpp_parsers::message::{Body, Message, MessageType};
use xmpp_parsers::ping::Ping;
```
Replacement in src/xmpp/stanzas.rs at line 4 [5.13]
∅:D[5.141] → [3.84:126]
```
use xmpp_parsers::roster::{Item, Roster};
```
[5.141]
[5.141]
```
use xmpp_parsers::roster::Roster;
```

Replacement in src/xmpp/stanzas.rs at line 16 [5.13]

∅:D[3.196] → [2.31:157]

    Iq::from_get(
        id,
        Roster {
            items: vec![],
            ver: None,
        },
    )
    .into()

[3.196]

[3.357]

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

Deletion in src/xmpp/stanzas.rs at line 23 [5.13]

∅:D[3.359] → [3.359:360]

∅:D[3.360] → [4.58:128]

∅:D[4.128] → [2.158:511]

∅:D[2.511] → [4.180:309]

∅:D[6.526] → [4.180:309]

∅:D[7.480] → [4.180:309]

∅:D[3.794] → [4.180:309]

∅:D[4.309] → [8.0:52]

∅:D[4.361] → [4.361:596]

∅:D[4.596] → [9.180:182]

∅:D[3.794] → [9.180:182]

∅:D[9.182] → [4.597:909]

∅:D[4.909] → [10.31:309]

∅:D[10.309] → [2.512:1184]


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()
}
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 [11.17]
∅:D[11.164] → [4.932:973]
```
use tokio_xmpp::{Client, Event, Packet};
```
[11.164]
[11.197]
```
use tokio_xmpp::{Client, Event};
```
Replacement in src/xmpp/mod.rs at line 8 [11.17]
∅:D[3.1193] → [3.1193:1236]
```
use std::collections::{HashMap, VecDeque};
```
[3.1193]
[5.420]
```
use std::collections::HashMap;
```

Insertion in src/xmpp/mod.rs at line 11 [11.17]

[5.434]

[12.430]

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
const ID_GET_ROSTER: &str = "id_get_roster0";
================================
mod element_processor;
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Replacement in src/xmpp/mod.rs at line 21 [11.17]

∅:D[3.1274] → [3.1274:1300]

∅:D[3.1300] → [13.0:163]

∅:D[4.1065] → [3.1391:1431]

∅:D[14.188] → [3.1391:1431]

∅:D[9.1023] → [3.1391:1431]

∅:D[15.97] → [3.1391:1431]

∅:D[13.163] → [3.1391:1431]

∅:D[16.97] → [3.1391:1431]

∅:D[3.1391] → [3.1391:1431]

∅:D[3.1431] → [13.164:289]

∅:D[4.1140] → [3.1616:1684]

∅:D[9.1098] → [3.1616:1684]

∅:D[15.163] → [3.1616:1684]

∅:D[13.289] → [3.1616:1684]

∅:D[16.163] → [3.1616:1684]

∅:D[3.1616] → [3.1616:1684]

∅:D[3.1684] → [13.290:378]

∅:D[13.378] → [10.1032:1104]

    /// 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>,

[3.1274]

[3.1786]

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

Insertion in src/xmpp/mod.rs at line 28 [11.17]

[3.1848]

}
struct XmppElementProcessor {
    incoming: element_processor::Processor<XmppConnection, (), xmpp_parsers::Element>,

Insertion in src/xmpp/mod.rs at line 34 [11.17]

[3.1851]

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

Replacement in src/xmpp/mod.rs at line 96 [11.17]

∅:D[3.2671] → [4.1141:1197]

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

[3.2671]

[11.944]

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

Replacement in src/xmpp/mod.rs at line 104 [11.17]

∅:D[17.1591] → [4.1198:1388]

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

[17.1591]

[11.1476]

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

Replacement in src/xmpp/mod.rs at line 111 [11.17]

∅:D[11.1477] → [4.1389:1593]

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

[11.1477]

[12.1065]

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

Replacement in src/xmpp/mod.rs at line 114 [11.17]

∅:D[12.1066] → [4.1594:2005]

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

[12.1066]

[17.3128]

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

Replacement in src/xmpp/mod.rs at line 140 [11.17]

∅:D[17.3162] → [4.2006:3023]

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

[17.3162]

[17.3192]

Replacement in src/xmpp/mod.rs at line 159 [11.17]

∅:D[17.3788] → [2.1185:1289]

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

[17.3788]

[3.4545]

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

Insertion in src/xmpp/mod.rs at line 165 [11.17]

[3.4606]

                let processors = XmppElementProcessor::new();
                processors.incoming.process(self, stanza.clone());

Replacement in src/xmpp/mod.rs at line 171 [11.17]

∅:D[3.4712] → [2.1290:1814]

∅:D[2.1814] → [4.3866:3903]

∅:D[6.1819] → [4.3866:3903]

∅:D[7.1068] → [4.3866:3903]

∅:D[13.1017] → [4.3866:3903]

∅:D[4.3866] → [4.3866:3903]

∅:D[4.3903] → [2.1815:2229]

∅:D[2.2229] → [4.4078:4113]

∅:D[6.1995] → [4.4078:4113]

∅:D[7.1483] → [4.4078:4113]

∅:D[4.4078] → [4.4078:4113]

∅:D[4.4113] → [3.5948:5978]

∅:D[9.3773] → [3.5948:5978]

∅:D[15.627] → [3.5948:5978]

∅:D[3.5948] → [3.5948:5978]

∅:D[3.5978] → [2.2230:2509]

∅:D[2.2509] → [3.5978:6026]

∅:D[7.1763] → [3.5978:6026]

∅:D[3.5978] → [3.5978:6026]

∅:D[3.6026] → [2.2510:3696]

∅:D[2.3696] → [4.6150:6184]

∅:D[6.2956] → [4.6150:6184]

∅:D[18.1186] → [4.6150:6184]

∅:D[13.1161] → [4.6150:6184]

∅:D[4.6150] → [4.6150:6184]

∅:D[4.6184] → [2.3697:4511]

∅:D[2.4511] → [4.6184:6214]

∅:D[6.3015] → [4.6184:6214]

∅:D[13.1220] → [4.6184:6214]

∅:D[4.6184] → [4.6184:6214]

∅:D[4.6214] → [3.8440:8466]

∅:D[9.5874] → [3.8440:8466]

∅:D[15.906] → [3.8440:8466]

∅:D[16.2826] → [3.8440:8466]

∅:D[3.8440] → [3.8440:8466]

∅:D[3.8466] → [2.4512:4555]

∅:D[2.4555] → [3.8466:8488]

∅:D[18.1419] → [3.8466:8488]

∅:D[3.8466] → [3.8466:8488]

∅:D[3.8488] → [2.4556:4762]

∅:D[2.4762] → [3.8488:8506]

∅:D[10.2195] → [3.8488:8506]

∅:D[15.1113] → [3.8488:8506]

∅:D[3.8488] → [3.8488:8506]

∅:D[3.8506] → [2.4763:4784]

                use std::convert::TryInto;
                if let Some(iq) = stanza.clone().try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                    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);
                            }
                        }
                        _ => (), // ignore
                    }
                } else if let Some(_presence) =
                    stanza.try_into().ok() as Option<xmpp_parsers::presence::Presence>
                {
                    // to do something with presence
                }
                true

[3.4712]

[3.8539]

                use try_from::TryInto;
                if let Some(_iq) = stanza.try_into().ok() as Option<xmpp_parsers::iq::Iq> {}
                future::ok(self)

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

∅:D[3.8553] → [2.4785:4820]

            Event::Online => true,

[3.8553]

[3.8600]

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

Replacement in src/xmpp/mod.rs at line 178 [11.17]
∅:D[3.8670] → [2.4821:4843]
```
                false
```
[3.8670]
[3.8712]
```
                future::err(self.account)
```

Replacement in src/xmpp/mod.rs at line 206 [11.17]

∅:D[3.9205] → [3.9205:9264]

                    state: XmppState { client, mut data },

[3.9205]

[3.9264]

                    state: XmppState { client, data },

Replacement in src/xmpp/mod.rs at line 209 [11.17]

∅:D[3.9319] → [3.9319:9498]

∅:D[3.9498] → [4.6340:7165]

∅:D[4.7165] → [19.6443:6477]

∅:D[3.10874] → [19.6443:6477]

∅:D[20.2179] → [19.6443:6477]

∅:D[19.6443] → [19.6443:6477]

∅:D[19.6477] → [4.7166:8168]

∅:D[4.8168] → [3.11761:11795]

∅:D[3.11761] → [3.11761:11795]

∅:D[3.11795] → [4.8169:9027]

∅:D[4.9027] → [3.11918:12288]

∅:D[3.11918] → [3.11918:12288]

∅:D[3.12288] → [2.4844:4916]

∅:D[2.4916] → [3.12356:12531]

∅:D[4.9096] → [3.12356:12531]

∅:D[6.3209] → [3.12356:12531]

∅:D[10.2349] → [3.12356:12531]

∅:D[15.1267] → [3.12356:12531]

∅:D[3.12356] → [3.12356:12531]

∅:D[3.12531] → [2.4917:5841]

∅:D[2.5841] → [3.13824:13920]

∅:D[4.10390] → [3.13824:13920]

∅:D[6.4503] → [3.13824:13920]

∅:D[10.3274] → [3.13824:13920]

∅:D[15.2192] → [3.13824:13920]

∅:D[3.13824] → [3.13824:13920]

∅:D[3.13920] → [2.5842:6023]

∅:D[2.6023] → [3.14245:14290]

∅:D[4.10716] → [3.14245:14290]

∅:D[6.4829] → [3.14245:14290]

∅:D[10.3456] → [3.14245:14290]

∅:D[15.2374] → [3.14245:14290]

∅:D[3.14245] → [3.14245:14290]

∅:D[3.14290] → [2.6024:6105]

∅:D[2.6105] → [3.14381:14512]

∅:D[4.10808] → [3.14381:14512]

∅:D[6.4921] → [3.14381:14512]

∅:D[10.3538] → [3.14381:14512]

∅:D[15.2456] → [3.14381:14512]

∅:D[3.14381] → [3.14381:14512]

∅:D[3.14512] → [2.6106:6181]

∅:D[2.6181] → [3.14596:15149]

∅:D[4.10893] → [3.14596:15149]

∅:D[6.5006] → [3.14596:15149]

∅:D[10.3614] → [3.14596:15149]

∅:D[15.2532] → [3.14596:15149]

∅:D[3.14596] → [3.14596:15149]

∅:D[3.15149] → [2.6182:6220]

∅:D[2.6220] → [3.15188:15348]

∅:D[4.10933] → [3.15188:15348]

∅:D[6.5046] → [3.15188:15348]

∅:D[10.3653] → [3.15188:15348]

∅:D[15.2571] → [3.15188:15348]

∅:D[3.15188] → [3.15188:15348]

∅:D[3.15348] → [2.6221:6298]

∅:D[2.6298] → [3.15435:15529]

∅:D[4.11021] → [3.15435:15529]

∅:D[6.5134] → [3.15435:15529]

∅:D[10.3731] → [3.15435:15529]

∅:D[15.2649] → [3.15435:15529]

∅:D[3.15435] → [3.15435:15529]

∅:D[3.15529] → [2.6299:6374]

∅:D[2.6374] → [3.15613:16146]

∅:D[4.11106] → [3.15613:16146]

∅:D[6.5219] → [3.15613:16146]

∅:D[10.3807] → [3.15613:16146]

∅:D[15.2725] → [3.15613:16146]

∅:D[3.15613] → [3.15613:16146]

∅:D[3.16146] → [2.6375:6413]

∅:D[2.6413] → [3.16185:16291]

∅:D[4.11146] → [3.16185:16291]

∅:D[6.5259] → [3.16185:16291]

∅:D[10.3846] → [3.16185:16291]

∅:D[15.2764] → [3.16185:16291]

∅:D[3.16185] → [3.16185:16291]


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

[3.9319]

[21.5580]

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

Replacement in src/xmpp/mod.rs at line 289 [11.17]

∅:D[3.16485] → [13.1221:1320]

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

[3.16485]

[3.16562]

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

Replacement in src/xmpp/mod.rs at line 291 [11.17]
∅:D[3.16604] → [2.6414:6453]
```
            use std::convert::TryInto;
```
[3.16604]
[3.16639]
```
            use try_from::TryInto;
```

Replacement in src/xmpp/mod.rs at line 294 [11.17]

∅:D[3.16735] → [2.6454:7514]

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

[3.16735]

[3.18104]

                    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(())

Deletion in src/xmpp/mod.rs at line 318 [11.17]

∅:D[3.18146] → [2.7515:7564]

                                        Ok(true)

Deletion in src/xmpp/mod.rs at line 319 [11.17]

∅:D[3.18412] → [2.7565:7777]

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

Replacement in src/xmpp/mod.rs at line 320 [11.17]

∅:D[6.7025] → [3.18635:18665]

∅:D[7.3305] → [3.18635:18665]

∅:D[3.18635] → [3.18635:18665]

∅:D[3.18665] → [2.7778:7921]

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

[6.7025]

[2.7921]

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

Insertion in src/xmpp/mod.rs at line 325 [11.17]

[2.7951]

[3.18736]

                        } else {
                            Ok(false)

Replacement in src/xmpp/mod.rs at line 329 [11.17]

∅:D[3.18791] → [2.7952:7986]

                        Ok(false)

[3.18791]

[3.18879]

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

Replacement in src/xmpp/mod.rs at line 351 [11.17]

∅:D[3.19318] → [3.19318:19369]

            state: XmppState { client, mut data },

[3.19318]

[3.19369]

            state: XmppState { client, data },

Replacement in src/xmpp/mod.rs at line 355 [11.17]

∅:D[22.8525] → [3.19422:19589]

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

[22.8525]

[3.19641]

        let get_roster = stanzas::make_get_roster(ID_GET_ROSTER);

Replacement in src/xmpp/mod.rs at line 360 [11.17]
∅:D[3.19750] → [4.11419:11465]
```
            .send(Packet::Stanza(get_roster))
```
[3.19750]
[3.19780]
```
            .send(get_roster)
```

Replacement in src/xmpp/mod.rs at line 370 [11.17]

∅:D[3.20084] → [13.1466:1638]

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

[3.20084]

[3.20165]

                .processing(XmppConnection::process_initial_roster, stop_future)

Replacement in src/xmpp/mod.rs at line 399 [11.17]
∅:D[23.6667] → [4.11466:11510]
```
            .send(Packet::Stanza(presence))
```
[23.6667]
[12.8226]
```
            .send(presence)
```

Replacement in src/xmpp/mod.rs at line 412 [11.17]

∅:D[12.8658] → [2.7987:8514]

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

[12.8658]

[12.9042]

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

Replacement in src/xmpp/mod.rs at line 436 [11.17]

∅:D[3.21632] → [13.1639:2916]

∅:D[13.2916] → [8.182:204]

∅:D[13.2938] → [13.2938:3628]

∅:D[13.3628] → [3.21632:21686]

∅:D[3.21632] → [3.21632: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) {

[3.21632]

[3.21686]

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

Replacement in src/xmpp/mod.rs at line 441 [11.17]

∅:D[3.21716] → [13.3629:3705]

∅:D[13.3705] → [4.12185:12238]

∅:D[4.12185] → [4.12185:12238]

∅:D[4.12238] → [13.3706:3902]

∅:D[13.3902] → [10.3847:4272]

∅:D[10.4272] → [2.8515:8835]

∅:D[2.8835] → [4.12344:12358]

∅:D[10.4272] → [4.12344:12358]

∅:D[13.3902] → [4.12344:12358]

∅:D[4.12344] → [4.12344:12358]

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

[3.21716]

[3.23186]

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

Insertion in src/xmpp/mod.rs at line 446 [11.17]
[3.23196]
[10.5042]
```
        future::ok(self)
```

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

∅:D[10.5048] → [10.5048:5049]

∅:D[10.5049] → [2.8836:9827]

∅:D[2.9827] → [10.5049:6586]

∅:D[10.5049] → [10.5049:6586]

∅:D[4.13784] → [17.12130:12136]

∅:D[12.9616] → [17.12130:12136]

∅:D[24.1922] → [17.12130:12136]

∅:D[22.10285] → [17.12130:12136]

∅:D[25.5866] → [17.12130:12136]

∅:D[10.6586] → [17.12130:12136]

∅:D[3.23196] → [17.12130:12136]

∅:D[26.4597] → [17.12130:12136]

∅:D[27.5862] → [17.12130:12136]

∅:D[18.2467] → [17.12130:12136]

∅:D[17.12130] → [17.12130:12136]


    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 451 [11.17]
∅:D[28.60] → [13.3903:4005]
∅:D[13.4005] → [10.6587:6658]
∅:D[10.6658] → [2.9828:9838]
∅:D[2.9838] → [4.13871:13873]
∅:D[24.1994] → [4.13871:13873]
∅:D[29.1834] → [4.13871:13873]
∅:D[10.6668] → [4.13871:13873]
∅:D[13.4005] → [4.13871:13873]
∅:D[4.13871] → [4.13871:13873]
```
pub enum XmppCommand {
    Chat {
        xmpp_to: xmpp_parsers::Jid,
        message: String,
    },
    Chatroom {
        muc_id: String,
        message: String,
    },
    Ping,
}
```
[28.60]
[11.3816]
```
pub struct XmppCommand;
```

Replacement in src/xmpp/mod.rs at line 491 [11.17]

∅:D[3.23809] → [3.23809:24278]

∅:D[3.24278] → [2.9839:9983]

∅:D[2.9983] → [3.24363:24419]

∅:D[6.7272] → [3.24363:24419]

∅:D[29.1979] → [3.24363:24419]

∅:D[10.6813] → [3.24363:24419]

∅:D[9.8572] → [3.24363:24419]

∅:D[30.1378] → [3.24363:24419]

∅:D[18.2553] → [3.24363:24419]

∅:D[31.85] → [3.24363:24419]

∅:D[16.3295] → [3.24363:24419]

∅:D[3.24363] → [3.24363: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)))
                            }
                        }

[3.23809]

[3.24419]

                    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 = _>>,

Replacement in src/xmpp/mod.rs at line 504 [11.17]

∅:D[3.24532] → [3.24532:24822]

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

[3.24532]

[3.24822]

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

Insertion in src/xmpp/mod.rs at line 514 [11.17]

[3.24858]

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

Replacement in src/xmpp/mod.rs at line 516 [11.17]

∅:D[3.24895] → [2.9984:10060]

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

[3.24895]

[3.24963]

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

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

∅:D[29.2257] → [2.10061:10261]

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

[29.2257]

[3.25109]

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

Replacement in src/xmpp/mod.rs at line 521 [11.17]
∅:D[3.25132] → [3.25132:25183]
∅:D[3.25132] → [3.25132:25183]
∅:D[3.25132] → [3.25132:25183]
∅:D[3.25132] → [3.25132:25183]
∅:D[3.25132] → [3.25132:25183]
∅:D[3.25132] → [3.25132:25183]
∅:D[3.25132] → [3.25132:25183]
∅:D[3.25132] → [3.25132:25183]
∅:D[3.25132] → [3.25132:25183]
∅:D[3.25132] → [3.25132:25183]
```
                    Err((account, r)) => match r {
```
[3.25132]
[3.25183]
```
                    Err((account, r)) => Box::new(match r {
```

Replacement in src/xmpp/mod.rs at line 542 [11.17]

∅:D[3.26249] → [2.10262:10332]

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

[3.26249]

[3.26317]

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

Replacement in src/xmpp/mod.rs at line 546 [11.17]
∅:D[3.26438] → [3.26438:26461]
```
                    },
```
[3.26438]
[3.26461]
```
                    }),
```

Deletion in src/xmpp/mod.rs at line 549 [11.17]

∅:D[10.7372] → [10.7372:7379]

∅:D[10.7379] → [2.10333: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(()))
        }

File addition: element_processor.rs (-rw-r--r--)

[11.7]

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

Deletion in src/main.rs at line 2 [32.17]
∅:D[16.3885] → [4.13874:13903]
```
#![deny(bare_trait_objects)]
```
Insertion in src/main.rs at line 7 [32.17]
[33.3621]
[33.3643]
```
extern crate minidom;
```
Insertion in src/main.rs at line 22 [32.17]
[33.3921]
[33.3953]
```
use hyper::service::service_fn;
```
Replacement in src/main.rs at line 28 [32.17]
∅:D[16.4155] → [4.13904:13948]
```
use tokio::prelude::{Future, Sink, Stream};
```
[16.4155]
[33.4092]
```
use tokio::prelude::Sink;
```

Deletion in src/main.rs at line 38 [32.17]

∅:D[16.4337] → [10.7380:7495]

∅:D[10.7495] → [2.10550:10593]

∅:D[2.10593] → [10.7538:7712]

∅:D[6.7533] → [10.7538:7712]

∅:D[10.7538] → [10.7538:7712]

∅:D[10.7712] → [24.2314:2315]

∅:D[24.2314] → [24.2314:2315]

∅:D[24.2315] → [4.13950:14630]

∅:D[4.13950] → [4.13950:14630]

∅:D[4.14630] → [2.10594:10749]

∅:D[2.10749] → [4.14867:14893]

∅:D[6.7771] → [4.14867:14893]

∅:D[29.2646] → [4.14867:14893]

∅:D[10.7868] → [4.14867:14893]

∅:D[18.3020] → [4.14867:14893]

∅:D[4.14867] → [4.14867:14893]

∅:D[31.551] → [24.2458:2459]

∅:D[24.2458] → [24.2458:2459]

∅:D[24.2459] → [10.7869:7954]

∅:D[10.7954] → [2.10750:10822]


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

Deletion in src/main.rs at line 39 [32.17]

∅:D[10.8027] → [10.8027:8105]

∅:D[24.2537] → [4.14948:15247]

∅:D[10.8105] → [4.14948:15247]

∅:D[18.3075] → [4.14948:15247]

∅:D[4.14948] → [4.14948:15247]

∅:D[4.15247] → [2.10823:10883]

∅:D[2.10883] → [4.15295:15385]

∅:D[6.7878] → [4.15295:15385]

∅:D[10.8166] → [4.15295:15385]

∅:D[18.3124] → [4.15295:15385]

∅:D[31.612] → [4.15295:15385]

∅:D[4.15295] → [4.15295:15385]

∅:D[4.15385] → [10.8167:8204]

∅:D[24.2575] → [4.15414:15523]

∅:D[10.8204] → [4.15414:15523]

∅:D[18.3154] → [4.15414:15523]

∅:D[4.15414] → [4.15414:15523]

∅:D[4.15523] → [10.8205:9485]

∅:D[10.9485] → [2.10884:10952]

∅:D[2.10952] → [10.9553:9908]

∅:D[6.7935] → [10.9553:9908]

∅:D[10.9553] → [10.9553:9908]

∅:D[10.9908] → [2.10953:11021]

∅:D[2.11021] → [10.9976:11636]

∅:D[6.7992] → [10.9976:11636]

∅:D[10.9976] → [10.9976:11636]

∅:D[10.11636] → [2.11022:11090]

∅:D[2.11090] → [10.11704:12059]

∅:D[6.8049] → [10.11704:12059]

∅:D[10.11704] → [10.11704:12059]

∅:D[10.12059] → [2.11091:11159]

∅:D[2.11159] → [10.12127:12696]

∅:D[6.8106] → [10.12127:12696]

∅:D[10.12127] → [10.12127:12696]

∅:D[10.12696] → [2.11160:11220]

∅:D[2.11220] → [10.12756:12832]

∅:D[6.8155] → [10.12756:12832]

∅:D[10.12756] → [10.12756:12832]

∅:D[10.12832] → [24.7130:7144]

∅:D[18.5760] → [24.7130:7144]

∅:D[24.7130] → [24.7130:7144]

∅:D[24.7144] → [4.18136:18237]

∅:D[4.18136] → [4.18136:18237]

∅:D[4.18237] → [3.31333:31334]

∅:D[9.13165] → [3.31333:31334]

∅:D[16.4337] → [3.31333:31334]

∅:D[3.31333] → [3.31333:31334]

∅:D[3.31334] → [4.18238:18716]

        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 72 [32.17]

∅:D[33.5155] → [2.11221:11293]

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

[33.5155]

[2.11293]

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

Deletion in src/main.rs at line 94 [32.17]

∅:D[33.6049] → [2.11305:12117]

    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(|_| ()),
        );
    }

Deletion in src/config.rs at line 0 [34.1396]
∅:D[34.1396] → [2.12118:12149]
```
use std::collections::HashMap;
```

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

∅:D[34.1502] → [4.18762:18845]

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

[34.1502]

[34.1523]

    pub jid: String,

Deletion in src/config.rs at line 8 [34.1396]

∅:D[34.1549] → [2.12150:12296]

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

Deletion in src/config.rs at line 25 [34.1396]

∅:D[34.1943] → [4.18846:19119]

∅:D[4.19119] → [2.12297:13046]

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

Deletion in README.md at line 0 [32.76]
∅:D[32.76] → [2.13047:13070]
∅:D[2.13070] → [6.8397:8398]
∅:D[6.8397] → [6.8397:8398]
∅:D[6.8398] → [2.13071:13093]
∅:D[2.13093] → [10.14705:14706]
∅:D[6.8423] → [10.14705:14706]
∅:D[10.14705] → [10.14705:14706]
∅:D[6.8543] → [10.14706:14785]
∅:D[10.14706] → [10.14706:14785]
∅:D[10.14785] → [2.13094:13123]
∅:D[2.13123] → [10.14814:14884]
∅:D[6.8572] → [10.14814:14884]
∅:D[10.14814] → [10.14814:14884]
```
### 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 [32.11995]
∅:D[33.6900] → [4.19120:19159]
```
tokio-xmpp = "1.0.0"
failure = "0.1.5"
```
[33.6900]
[33.6935]
```
tokio-xmpp = "0.2"
failure = "0.1"
```
Replacement in Cargo.toml at line 15 [32.11995]
∅:D[33.6950] → [2.13124:13137]
```
toml = "0.5"
```
[33.6950]
[33.6963]
```
toml = "0.4"
```
Replacement in Cargo.toml at line 21 [32.11995]
∅:D[16.6425] → [2.13138:13160]
∅:D[2.13160] → [4.19184:19219]
∅:D[6.8611] → [4.19184:19219]
∅:D[7.3377] → [4.19184:19219]
∅:D[4.19184] → [4.19184:19219]
```
xmpp-parsers = "0.13"
minidom = "=0.10.0" # xmpp-parsers
```
[16.6425]
```
minidom = "=0.9.1" # dependency of tokio-xmpp
xmpp-parsers = "0.11"
try_from = "=0.2.2" # dependency of xmpp-parsers
```

Deletion in Cargo.lock at line 0 [32.12201]

∅:D[32.12201] → [2.13161:13252]

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

Deletion in Cargo.lock at line 1 [32.12201]
∅:D[16.6555] → [4.19255:19377]
∅:D[4.19377] → [2.13253:13325]
∅:D[2.13325] → [4.19449:19464]
∅:D[6.8684] → [4.19449:19464]
∅:D[29.4545] → [4.19449:19464]
∅:D[7.3450] → [4.19449:19464]
∅:D[10.15049] → [4.19449:19464]
∅:D[18.5878] → [4.19449:19464]
∅:D[31.1114] → [4.19449:19464]
∅:D[4.19449] → [4.19449:19464]
```
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 2 [32.12201]
∅:D[16.6577] → [2.13326:13344]
```
version = "0.7.3"
```
[16.6577]
[16.6595]
```
version = "0.6.9"
```

Replacement in Cargo.lock at line 5 [32.12201]

∅:D[16.6677] → [2.13345:13418]

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

[16.6677]

[16.6750]

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

Replacement in Cargo.lock at line 13 [32.12201]

∅:D[33.7455] → [2.13419:13492]

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

[33.7455]

[33.7528]

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

Replacement in Cargo.lock at line 18 [32.12201]

∅:D[33.7561] → [2.13493:13512]

version = "0.3.10"

[33.7561]

[35.1388]

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

Replacement in Cargo.lock at line 28 [32.12201]
∅:D[33.7789] → [4.19558:19577]
```
version = "0.4.10"
```
[33.7789]
[33.7807]
```
version = "0.4.8"
```

Replacement in Cargo.lock at line 39 [32.12201]

∅:D[33.8093] → [2.13513:13585]

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

[33.8093]

[33.8165]

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

Replacement in Cargo.lock at line 41 [32.12201]

∅:D[33.8239] → [2.13586:13659]

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

[33.8239]

[33.8312]

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

Replacement in Cargo.lock at line 45 [32.12201]
∅:D[36.10388] → [4.19651:19686]
```
name = "autocfg"
version = "0.1.2"
```
[36.10388]
[33.8364]
```
name = "backtrace"
version = "0.2.3"
```

Insertion in Cargo.lock at line 48 [32.12201]

[33.8429]

[33.8985]

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 60 [32.12201]
∅:D[33.9017] → [2.13660:13679]
```
version = "0.3.15"
```
[33.9017]
[33.9035]
```
version = "0.3.9"
```

Replacement in Cargo.lock at line 63 [32.12201]

∅:D[33.9117] → [4.19707:19862]

∅:D[4.19862] → [2.13680:13980]

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

[33.9117]

[33.9497]

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

Replacement in Cargo.lock at line 72 [32.12201]
∅:D[33.9535] → [4.20018:20037]
```
version = "0.1.28"
```
[33.9535]
[33.9554]
```
version = "0.1.24"
```

Replacement in Cargo.lock at line 75 [32.12201]

∅:D[33.9636] → [2.13981:14123]

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

[33.9636]

[33.9778]

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

Replacement in Cargo.lock at line 81 [32.12201]
∅:D[33.9809] → [4.20181:20200]
```
version = "0.10.1"
```
[33.9809]
[33.9827]
```
version = "0.9.3"
```

Replacement in Cargo.lock at line 84 [32.12201]

∅:D[33.9909] → [4.20201:20277]

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

[33.9909]

[33.10059]

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

Replacement in Cargo.lock at line 95 [32.12201]
∅:D[33.10204] → [4.20278:20296]
```
version = "0.8.0"
```
[33.10204]
[33.10222]
```
version = "0.7.1"
```

Replacement in Cargo.lock at line 98 [32.12201]

∅:D[33.10304] → [4.20297:20603]

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

[33.10304]

[33.10531]

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

Replacement in Cargo.lock at line 105 [32.12201]
∅:D[33.10568] → [2.14124:14142]
```
version = "0.7.0"
```
[33.10568]
[9.15479]
```
version = "0.3.3"
```

Replacement in Cargo.lock at line 108 [32.12201]

∅:D[9.15561] → [4.20623:20937]

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

[9.15561]

[4.20937]

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

Deletion in Cargo.lock at line 113 [32.12201]

∅:D[4.20952] → [4.20952:21152]

∅:D[4.21152] → [9.15875:15890]

∅:D[15.6489] → [9.15875:15890]

∅:D[9.15875] → [9.15875:15890]

name = "block-padding"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]

Replacement in Cargo.lock at line 114 [32.12201]
∅:D[33.10855] → [4.21153:21171]
```
version = "0.3.1"
```
[33.10855]
[33.10873]
```
version = "0.2.0"
```
Replacement in Cargo.lock at line 119 [32.12201]
∅:D[33.10970] → [4.21172:21190]
```
version = "1.3.1"
```
[33.10970]
[33.10988]
```
version = "1.2.7"
```
Replacement in Cargo.lock at line 124 [32.12201]
∅:D[33.11081] → [2.14143:14162]
```
version = "0.4.12"
```
[33.11081]
[33.11100]
```
version = "0.4.11"
```

Replacement in Cargo.lock at line 127 [32.12201]

∅:D[33.11182] → [4.21191:21267]

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

[33.11182]

[33.11258]

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

Replacement in Cargo.lock at line 138 [32.12201]
∅:D[33.11467] → [2.14163:14182]
```
version = "1.0.35"
```
[33.11467]
[33.11486]
```
version = "1.0.25"
```
Replacement in Cargo.lock at line 143 [32.12201]
∅:D[33.11580] → [2.14183:14201]
```
version = "0.1.7"
```
[33.11580]
[33.11598]
```
version = "0.1.6"
```

Replacement in Cargo.lock at line 153 [32.12201]

∅:D[33.11948] → [4.21288:21360]

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

[33.11948]

[33.12020]

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

Replacement in Cargo.lock at line 158 [32.12201]
∅:D[33.12049] → [2.14202:14221]
```
version = "2.33.0"
```
[33.12049]
[33.12068]
```
version = "2.32.0"
```

Replacement in Cargo.lock at line 164 [32.12201]

∅:D[33.12374] → [2.14222:14371]

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

[33.12374]

[33.12523]

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

Insertion in Cargo.lock at line 177 [32.12201]

[33.12887]

[33.13009]


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

Replacement in Cargo.lock at line 189 [32.12201]

∅:D[33.13233] → [2.14372:14444]

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

[33.13233]

[33.13305]

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

Replacement in Cargo.lock at line 197 [32.12201]

∅:D[6.10117] → [2.14445:14517]

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

[6.10117]

[33.13825]

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

Replacement in Cargo.lock at line 202 [32.12201]
∅:D[6.10219] → [2.14518:14536]
```
version = "0.7.1"
```
[6.10219]
[33.13883]
```
version = "0.6.2"
```

Replacement in Cargo.lock at line 205 [32.12201]

∅:D[33.13965] → [6.10238:10320]

∅:D[6.10320] → [4.22854:22936]

∅:D[29.5096] → [4.22854:22936]

∅:D[7.4091] → [4.22854:22936]

∅:D[31.1907] → [4.22854:22936]

∅:D[33.14113] → [4.22854:22936]

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

[33.13965]

[10.15736]

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

Replacement in Cargo.lock at line 211 [32.12201]
∅:D[6.10346] → [6.10346:10364]
```
version = "0.7.1"
```
[6.10346]
[10.15794]
```
version = "0.6.1"
```

Replacement in Cargo.lock at line 214 [32.12201]

∅:D[10.15876] → [6.10365:10441]

∅:D[6.10441] → [2.14537:14610]

∅:D[2.14610] → [10.15876:15958]

∅:D[6.10514] → [10.15876:15958]

∅:D[10.15876] → [10.15876:15958]

∅:D[10.15958] → [2.14611:14689]

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

[10.15876]

[6.10593]

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

Replacement in Cargo.lock at line 223 [32.12201]
∅:D[33.14441] → [2.14690:14733]
```
name = "crossbeam-queue"
version = "0.1.2"
```
[33.14441]
[2.14733]
```
name = "crossbeam-utils"
version = "0.6.1"
```

Replacement in Cargo.lock at line 227 [32.12201]

∅:D[2.14815] → [2.14815:14897]

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

[2.14815]

[2.14897]

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

Replacement in Cargo.lock at line 231 [32.12201]
∅:D[2.14912] → [33.14441:14466]
∅:D[33.14441] → [33.14441:14466]
∅:D[33.14466] → [4.22937:22955]
```
name = "crossbeam-utils"
version = "0.6.5"
```
[2.14912]
[35.4227]
```
name = "crypto-mac"
version = "0.5.2"
```

Replacement in Cargo.lock at line 235 [32.12201]

∅:D[16.7801] → [2.14913:15064]

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

[16.7801]

[16.7874]

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

Replacement in Cargo.lock at line 240 [32.12201]
∅:D[35.4305] → [35.4305:4325]
∅:D[35.4305] → [35.4305:4325]
∅:D[35.4325] → [4.23035:23053]
```
name = "crypto-mac"
version = "0.7.0"
```
[35.4305]
[15.7366]
```
name = "dbghelp-sys"
version = "0.2.0"
```

Replacement in Cargo.lock at line 244 [32.12201]

∅:D[15.7448] → [4.23054:23208]

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

[15.7448]

[15.7611]

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

Replacement in Cargo.lock at line 260 [32.12201]
∅:D[33.15609] → [4.23209:23227]
```
version = "0.8.0"
```
[33.15609]
[33.15627]
```
version = "0.7.6"
```

Replacement in Cargo.lock at line 263 [32.12201]

∅:D[33.15709] → [4.23228:23309]

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

[33.15709]

[33.15789]

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

Replacement in Cargo.lock at line 268 [32.12201]
∅:D[33.15825] → [2.15065:15084]
```
version = "0.8.17"
```
[33.15825]
[33.15844]
```
version = "0.8.12"
```

Replacement in Cargo.lock at line 271 [32.12201]

∅:D[33.15926] → [2.15085:15158]

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

[33.15926]

[16.7897]

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

Replacement in Cargo.lock at line 276 [32.12201]
∅:D[16.7932] → [2.15159:15177]
```
version = "0.6.1"
```
[16.7932]
[16.7950]
```
version = "0.6.0"
```

Replacement in Cargo.lock at line 282 [32.12201]

∅:D[16.8250] → [2.15178:15250]

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

[16.8250]

[16.8322]

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

Insertion in Cargo.lock at line 288 [32.12201]

[35.4842]

[33.16749]

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 299 [32.12201]

∅:D[33.16849] → [2.15251:15328]

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

[33.16849]

[33.16925]

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

Replacement in Cargo.lock at line 304 [32.12201]
∅:D[33.16957] → [4.23481:23499]
```
version = "0.1.5"
```
[33.16957]
[33.16975]
```
version = "0.1.3"
```

Replacement in Cargo.lock at line 307 [32.12201]

∅:D[33.17057] → [2.15329:15406]

∅:D[2.15406] → [4.23577:23658]

∅:D[6.11240] → [4.23577:23658]

∅:D[10.16286] → [4.23577:23658]

∅:D[18.7958] → [4.23577:23658]

∅:D[31.2703] → [4.23577:23658]

∅:D[4.23577] → [4.23577:23658]

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

[33.17057]

[33.17214]

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

Replacement in Cargo.lock at line 313 [32.12201]
∅:D[33.17253] → [4.23659:23677]
```
version = "0.1.5"
```
[33.17253]
[33.17271]
```
version = "0.1.3"
```

Replacement in Cargo.lock at line 316 [32.12201]

∅:D[33.17353] → [4.23678:23757]

∅:D[4.23757] → [2.15407:15552]

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

[33.17353]

[16.8623]

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

Deletion in Cargo.lock at line 342 [32.12201]

∅:D[33.18151] → [4.23903:24022]

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

Replacement in Cargo.lock at line 365 [32.12201]

∅:D[33.18854] → [2.15553:15641]

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

[33.18854]

[33.18942]

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

Replacement in Cargo.lock at line 370 [32.12201]
∅:D[33.18974] → [2.15642:15661]
```
version = "0.1.26"
```
[33.18974]
[33.18993]
```
version = "0.1.25"
```

Replacement in Cargo.lock at line 378 [32.12201]

∅:D[33.19196] → [2.15662:15813]

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

[33.19196]

[33.19346]

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

Replacement in Cargo.lock at line 384 [32.12201]
∅:D[33.19384] → [4.24099:24118]
```
version = "0.12.0"
```
[33.19384]
[33.19402]
```
version = "0.9.0"
```
Replacement in Cargo.lock at line 392 [32.12201]
∅:D[33.19586] → [2.15814:15833]
```
version = "0.1.18"
```
[33.19586]
[33.19605]
```
version = "0.1.14"
```

Replacement in Cargo.lock at line 395 [32.12201]

∅:D[33.19687] → [4.24139:24215]

∅:D[4.24215] → [2.15834:15907]

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

[33.19687]

[33.19836]

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

Replacement in Cargo.lock at line 398 [32.12201]

∅:D[33.19906] → [2.15908:16055]

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

[33.19906]

[33.20053]

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

Replacement in Cargo.lock at line 402 [32.12201]

∅:D[16.8941] → [4.24289:24433]

∅:D[4.24433] → [2.16056:16132]

∅:D[2.16132] → [4.24509:24788]

∅:D[6.11722] → [4.24509:24788]

∅:D[10.16675] → [4.24509:24788]

∅:D[18.8346] → [4.24509:24788]

∅:D[31.3166] → [4.24509:24788]

∅:D[4.24509] → [4.24509:24788]

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

[16.8941]

[9.18475]

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

Replacement in Cargo.lock at line 412 [32.12201]

∅:D[33.20551] → [2.16133:16205]

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

[33.20551]

[33.20623]

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

Replacement in Cargo.lock at line 418 [32.12201]
∅:D[33.20726] → [2.16206:16225]
```
version = "0.1.17"
```
[33.20726]
[33.20745]
```
version = "0.1.14"
```

Replacement in Cargo.lock at line 421 [32.12201]

∅:D[33.20827] → [2.16226:16299]

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

[33.20827]

[33.20900]

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

Replacement in Cargo.lock at line 441 [32.12201]
∅:D[33.21397] → [2.16300:16320]
```
version = "0.12.27"
```
[33.21397]
[33.21417]
```
version = "0.12.17"
```

Replacement in Cargo.lock at line 444 [32.12201]

∅:D[33.21499] → [2.16321:16469]

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

[33.21499]

[33.21647]

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

Replacement in Cargo.lock at line 447 [32.12201]

∅:D[33.21729] → [2.16470:16612]

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

[33.21729]

[33.21871]

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

Replacement in Cargo.lock at line 454 [32.12201]

∅:D[33.22231] → [2.16613:16693]

∅:D[2.16693] → [4.25046:25118]

∅:D[10.16943] → [4.25046:25118]

∅:D[31.3582] → [4.25046:25118]

∅:D[33.22231] → [4.25046:25118]

∅:D[4.25118] → [2.16694:17004]

∅:D[2.17004] → [4.25428:25504]

∅:D[6.12358] → [4.25428:25504]

∅:D[10.17174] → [4.25428:25504]

∅:D[18.8764] → [4.25428:25504]

∅:D[31.3813] → [4.25428:25504]

∅:D[4.25428] → [4.25428:25504]

∅:D[4.25504] → [2.17005:17089]

∅:D[2.17089] → [4.25588:25667]

∅:D[6.12443] → [4.25588:25667]

∅:D[10.17259] → [4.25588:25667]

∅:D[18.8849] → [4.25588:25667]

∅:D[31.3898] → [4.25588:25667]

∅:D[4.25588] → [4.25588:25667]

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

[33.22231]

[33.22850]

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

Replacement in Cargo.lock at line 472 [32.12201]

∅:D[33.23203] → [4.25668:25756]

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

[33.23203]

[33.23291]

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

Replacement in Cargo.lock at line 485 [32.12201]

∅:D[33.23535] → [2.17090:17162]

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

[33.23535]

[33.23607]

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

Replacement in Cargo.lock at line 497 [32.12201]

∅:D[33.24042] → [2.17163:17236]

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

[33.24042]

[33.24115]

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

Replacement in Cargo.lock at line 508 [32.12201]
∅:D[33.24326] → [4.25830:25848]
```
version = "0.5.3"
```
[33.24326]
[33.24344]
```
version = "0.5.2"
```

Replacement in Cargo.lock at line 511 [32.12201]

∅:D[33.24426] → [4.25849:26079]

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

[33.24426]

[33.24655]

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

Replacement in Cargo.lock at line 532 [32.12201]
∅:D[33.25092] → [2.17237:17255]
```
version = "1.3.0"
```
[33.25092]
[33.25110]
```
version = "1.2.0"
```
Replacement in Cargo.lock at line 542 [32.12201]
∅:D[33.25316] → [2.17256:17275]
```
version = "0.2.51"
```
[33.25316]
[33.25335]
```
version = "0.2.44"
```
Replacement in Cargo.lock at line 547 [32.12201]
∅:D[33.25438] → [2.17276:17294]
```
version = "0.5.2"
```
[33.25438]
[33.25456]
```
version = "0.4.2"
```

Replacement in Cargo.lock at line 564 [32.12201]

∅:D[33.25934] → [2.17295:17368]

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

[33.25934]

[33.26007]

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

Replacement in Cargo.lock at line 569 [32.12201]
∅:D[33.26041] → [2.17369:17387]
```
version = "0.1.2"
```
[33.26041]
[33.26059]
```
version = "0.1.1"
```

Replacement in Cargo.lock at line 572 [32.12201]

∅:D[33.26141] → [2.17388:17470]

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

[33.26141]

[33.26223]

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

Replacement in Cargo.lock at line 582 [32.12201]
∅:D[33.26368] → [4.26100:26118]
```
version = "0.7.5"
```
[33.26368]
[33.26386]
```
version = "0.7.3"
```

Replacement in Cargo.lock at line 585 [32.12201]

∅:D[33.26468] → [4.26119:26269]

∅:D[4.26269] → [2.17471:17702]

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

[33.26468]

[33.26849]

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

Replacement in Cargo.lock at line 592 [32.12201]

∅:D[33.27015] → [4.26501:26575]

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

[33.27015]

[33.27089]

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

Replacement in Cargo.lock at line 602 [32.12201]
∅:D[33.27233] → [2.17703:17721]
```
version = "2.2.0"
```
[33.27233]
[33.27251]
```
version = "2.1.1"
```

Insertion in Cargo.lock at line 604 [32.12201]

[33.27316]

[33.27560]

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 617 [32.12201]
∅:D[33.27705] → [4.26668:26687]
```
version = "0.10.0"
```
[33.27705]
[33.27723]
```
version = "0.9.1"
```

Replacement in Cargo.lock at line 620 [32.12201]

∅:D[33.27805] → [4.26688:26843]

∅:D[4.26843] → [2.17722:17799]

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

[33.27805]

[33.28037]

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

Replacement in Cargo.lock at line 635 [32.12201]

∅:D[16.10535] → [2.17800:17872]

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

[16.10535]

[16.10607]

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

Replacement in Cargo.lock at line 639 [32.12201]

∅:D[33.28843] → [4.26994:27065]

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

[33.28843]

[33.28914]

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

Replacement in Cargo.lock at line 649 [32.12201]

∅:D[33.29191] → [2.17873:17945]

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

[33.29191]

[33.29263]

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

Replacement in Cargo.lock at line 669 [32.12201]

∅:D[33.29899] → [2.17946:18096]

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

[33.29899]

[16.10901]

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

Replacement in Cargo.lock at line 672 [32.12201]

∅:D[16.10971] → [2.18097:18173]

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

[16.10971]

[33.30195]

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

Replacement in Cargo.lock at line 674 [32.12201]

∅:D[33.30275] → [2.18174:18329]

∅:D[2.18329] → [4.27369:27543]

∅:D[6.13774] → [4.27369:27543]

∅:D[10.18230] → [4.27369:27543]

∅:D[18.9985] → [4.27369:27543]

∅:D[31.4943] → [4.27369:27543]

∅:D[33.30430] → [4.27369:27543]

∅:D[4.27543] → [2.18330:18405]

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

[33.30275]

[33.30679]

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

Replacement in Cargo.lock at line 686 [32.12201]

∅:D[33.30809] → [2.18406:18624]

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

[33.30809]

[33.31027]

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

Replacement in Cargo.lock at line 693 [32.12201]
∅:D[33.31073] → [2.18625:18643]
```
version = "1.0.3"
```
[33.31073]
[33.31091]
```
version = "1.0.1"
```

Insertion in Cargo.lock at line 695 [32.12201]

[33.31156]

[33.31253]

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

Replacement in Cargo.lock at line 719 [32.12201]
∅:D[33.31727] → [2.18644:18663]
```
version = "1.10.0"
```
[33.31727]
[33.31745]
```
version = "1.8.0"
```

Replacement in Cargo.lock at line 722 [32.12201]

∅:D[33.31827] → [2.18664:18736]

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

[33.31827]

[33.31899]

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

Deletion in Cargo.lock at line 724 [32.12201]

∅:D[33.31901] → [4.27784:27902]


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

Replacement in Cargo.lock at line 727 [32.12201]
∅:D[33.31931] → [2.18737:18757]
```
version = "0.10.20"
```
[33.31931]
[33.31951]
```
version = "0.10.15"
```

Replacement in Cargo.lock at line 731 [32.12201]

∅:D[33.32108] → [2.18758:18831]

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

[33.32108]

[33.32181]

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

Replacement in Cargo.lock at line 733 [32.12201]

∅:D[33.32261] → [2.18832:19061]

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

[33.32261]

[33.32490]

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

Replacement in Cargo.lock at line 745 [32.12201]
∅:D[33.32645] → [2.19062:19081]
```
version = "0.9.43"
```
[33.32645]
[33.32664]
```
version = "0.9.39"
```

Replacement in Cargo.lock at line 748 [32.12201]

∅:D[33.32746] → [2.19082:19224]

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

[33.32746]

[33.32888]

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

Deletion in Cargo.lock at line 751 [32.12201]

∅:D[33.32966] → [2.19225:19305]

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

Replacement in Cargo.lock at line 764 [32.12201]
∅:D[33.33294] → [4.28239:28257]
```
version = "0.7.1"
```
[33.33294]
[33.33312]
```
version = "0.6.4"
```

Replacement in Cargo.lock at line 768 [32.12201]

∅:D[16.11532] → [4.28258:28341]

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

[16.11532]

[33.33552]

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

Replacement in Cargo.lock at line 773 [32.12201]
∅:D[33.33593] → [4.28342:28360]
```
version = "0.4.0"
```
[33.33593]
[33.33611]
```
version = "0.3.1"
```
Replacement in Cargo.lock at line 776 [32.12201]
∅:D[33.33693] → [2.19306:19378]
∅:D[2.19378] → [4.28433:28504]
∅:D[6.14766] → [4.28433:28504]
∅:D[29.6529] → [4.28433:28504]
∅:D[7.6157] → [4.28433:28504]
∅:D[10.19059] → [4.28433:28504]
∅:D[18.10830] → [4.28433:28504]
∅:D[31.5919] → [4.28433:28504]
∅:D[4.28433] → [4.28433:28504]
```
 "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)",
```
[33.33693]
[33.33836]
```
 "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)",
```

Replacement in Cargo.lock at line 779 [32.12201]

∅:D[33.33916] → [2.19379:19527]

∅:D[2.19527] → [4.28581:28865]

∅:D[33.34064] → [4.28581:28865]

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

[33.33916]

[3.40242]

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

Replacement in Cargo.lock at line 790 [32.12201]
∅:D[33.34214] → [4.28866:28885]
```
version = "0.7.24"
```
[33.34214]
[33.34233]
```
version = "0.7.23"
```

Replacement in Cargo.lock at line 793 [32.12201]

∅:D[33.34315] → [4.28886:28964]

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

[33.34315]

[33.34393]

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

Replacement in Cargo.lock at line 798 [32.12201]
∅:D[33.34429] → [4.28965:28984]
```
version = "0.7.24"
```
[33.34429]
[33.34448]
```
version = "0.7.23"
```

Replacement in Cargo.lock at line 801 [32.12201]

∅:D[33.34530] → [4.28985:29144]

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

[33.34530]

[33.34689]

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

Replacement in Cargo.lock at line 807 [32.12201]
∅:D[33.34727] → [4.29145:29164]
```
version = "0.7.24"
```
[33.34727]
[33.34746]
```
version = "0.7.23"
```

Replacement in Cargo.lock at line 810 [32.12201]

∅:D[33.34828] → [4.29165:29314]

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

[33.34828]

[33.34977]

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

Replacement in Cargo.lock at line 816 [32.12201]
∅:D[33.35012] → [4.29315:29334]
```
version = "0.7.24"
```
[33.35012]
[33.35031]
```
version = "0.7.23"
```
Replacement in Cargo.lock at line 834 [32.12201]
∅:D[33.35464] → [4.29335:29354]
```
version = "0.4.27"
```
[33.35464]
[33.35483]
```
version = "0.4.24"
```
Replacement in Cargo.lock at line 847 [32.12201]
∅:D[33.35794] → [2.19528:19547]
```
version = "0.13.3"
```
[33.35794]
[33.35813]
```
version = "0.12.4"
```
Replacement in Cargo.lock at line 850 [32.12201]
∅:D[33.35895] → [2.19548:19627]
∅:D[37.916] → [4.29454:29528]
∅:D[2.19627] → [4.29454:29528]
∅:D[6.14942] → [4.29454:29528]
∅:D[10.19235] → [4.29454:29528]
∅:D[18.11006] → [4.29454:29528]
∅:D[13.5268] → [4.29454:29528]
∅:D[31.6095] → [4.29454:29528]
∅:D[4.29454] → [4.29454:29528]
```
 "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)",
```
[33.35895]
[16.11782]
```
 "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)",
```

Replacement in Cargo.lock at line 853 [32.12201]

∅:D[16.11852] → [2.19628:19701]

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

[16.11852]

[33.36191]

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

Replacement in Cargo.lock at line 863 [32.12201]
∅:D[33.36333] → [2.19702:19721]
```
version = "0.6.12"
```
[33.36333]
[15.13435]
```
version = "0.6.10"
```

Replacement in Cargo.lock at line 866 [32.12201]

∅:D[15.13517] → [4.29623:29702]

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

[15.13517]

[33.37374]

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

Replacement in Cargo.lock at line 881 [32.12201]
∅:D[33.37392] → [4.29703:29721]
```
version = "0.5.6"
```
[33.37392]
[33.37410]
```
version = "0.5.5"
```

Replacement in Cargo.lock at line 885 [32.12201]

∅:D[35.12070] → [4.29722:29802]

∅:D[4.29802] → [2.19722:19794]

∅:D[2.19794] → [4.29874:29950]

∅:D[6.15089] → [4.29874:29950]

∅:D[29.6602] → [4.29874:29950]

∅:D[7.6230] → [4.29874:29950]

∅:D[10.19382] → [4.29874:29950]

∅:D[18.11153] → [4.29874:29950]

∅:D[31.6242] → [4.29874:29950]

∅:D[4.29874] → [4.29874:29950]

∅:D[4.29950] → [2.19795:19868]

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

[35.12070]

[16.12245]

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

Replacement in Cargo.lock at line 893 [32.12201]
∅:D[16.12274] → [4.29951:29969]
```
version = "0.6.5"
```
[16.12274]
[16.12292]
```
version = "0.6.1"
```

Replacement in Cargo.lock at line 896 [32.12201]

∅:D[16.12374] → [4.29970:30044]

∅:D[4.30044] → [2.19869:19941]

∅:D[2.19941] → [4.30116:30270]

∅:D[6.15162] → [4.30116:30270]

∅:D[29.6675] → [4.30116:30270]

∅:D[7.6303] → [4.30116:30270]

∅:D[10.19455] → [4.30116:30270]

∅:D[18.11226] → [4.30116:30270]

∅:D[31.6315] → [4.30116:30270]

∅:D[4.30116] → [4.30116:30270]

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

[16.12374]

[16.12756]

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

Replacement in Cargo.lock at line 903 [32.12201]

∅:D[16.12907] → [4.30271:30349]

∅:D[4.30349] → [2.19942:20091]

∅:D[2.20091] → [4.30424:30504]

∅:D[6.15312] → [4.30424:30504]

∅:D[10.19531] → [4.30424:30504]

∅:D[18.11302] → [4.30424:30504]

∅:D[31.6465] → [4.30424:30504]

∅:D[16.12982] → [4.30424:30504]

∅:D[4.30504] → [2.20092:20165]

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

[16.12907]

[16.13143]

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

Replacement in Cargo.lock at line 911 [32.12201]
∅:D[16.13179] → [4.30505:30523]
```
version = "0.1.1"
```
[16.13179]
[16.13197]
```
version = "0.1.0"
```

Replacement in Cargo.lock at line 914 [32.12201]

∅:D[16.13279] → [4.30524:30674]

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

[16.13279]

[33.38333]

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

Replacement in Cargo.lock at line 920 [32.12201]
∅:D[33.38659] → [4.30675:30693]
```
version = "0.3.1"
```
[33.38659]
[33.38677]
```
version = "0.2.2"
```

Replacement in Cargo.lock at line 923 [32.12201]

∅:D[33.38759] → [4.30694:30770]

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

[33.38759]

[33.38835]

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

Replacement in Cargo.lock at line 928 [32.12201]
∅:D[33.38869] → [4.30771:30789]
```
version = "0.4.0"
```
[33.38869]
[16.13436]
```
version = "0.3.0"
```

Replacement in Cargo.lock at line 936 [32.12201]

∅:D[16.13631] → [4.30790:30866]

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

[16.13631]

[16.13707]

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

Replacement in Cargo.lock at line 944 [32.12201]

∅:D[16.13778] → [4.30867:30943]

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

[16.13778]

[4.30943]

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

Deletion in Cargo.lock at line 948 [32.12201]
∅:D[4.30958] → [4.30958:31079]
∅:D[4.31079] → [2.20166:20238]
∅:D[2.20238] → [4.31151:31227]
∅:D[6.15385] → [4.31151:31227]
∅:D[29.6823] → [4.31151:31227]
∅:D[7.6451] → [4.31151:31227]
∅:D[10.19604] → [4.31151:31227]
∅:D[18.11375] → [4.31151:31227]
∅:D[31.6538] → [4.31151:31227]
∅:D[4.31151] → [4.31151:31227]
∅:D[4.31227] → [2.20239:20312]
∅:D[2.20312] → [4.31300:31332]
∅:D[4.31300] → [4.31300:31332]
∅:D[4.31332] → [2.20313:20331]
∅:D[2.20331] → [4.31350:31587]
∅:D[6.15404] → [4.31350:31587]
∅:D[29.6842] → [4.31350:31587]
∅:D[7.6470] → [4.31350:31587]
∅:D[31.6557] → [4.31350:31587]
∅:D[4.31350] → [4.31350:31587]
∅:D[4.31587] → [2.20332:20404]
∅:D[2.20404] → [4.31659:31808]
∅:D[6.15477] → [4.31659:31808]
∅:D[29.6915] → [4.31659:31808]
∅:D[7.6543] → [4.31659:31808]
∅:D[10.19677] → [4.31659:31808]
∅:D[18.11448] → [4.31659:31808]
∅:D[31.6630] → [4.31659:31808]
∅:D[4.31659] → [4.31659:31808]
∅:D[4.31808] → [2.20405:20478]
∅:D[2.20478] → [16.13854:13856]
∅:D[4.31881] → [16.13854:13856]
∅:D[9.24485] → [16.13854:13856]
∅:D[16.13854] → [16.13854:13856]
∅:D[16.13856] → [33.38952:38965]
∅:D[33.38952] → [33.38952:38965]
```
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)",
]
[[package]]
```
Replacement in Cargo.lock at line 949 [32.12201]
∅:D[16.13875] → [2.20479:20497]
```
version = "0.1.2"
```
[16.13875]
[16.13893]
```
version = "0.1.1"
```

Replacement in Cargo.lock at line 952 [32.12201]

∅:D[16.13975] → [2.20498:20648]

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

[16.13975]

[16.14131]

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

Replacement in Cargo.lock at line 958 [32.12201]
∅:D[16.14169] → [4.31959:31977]
```
version = "0.1.1"
```
[16.14169]
[4.31977]
```
version = "0.1.0"
```

Replacement in Cargo.lock at line 961 [32.12201]

∅:D[4.32059] → [4.32059:32135]

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

[4.32059]

[4.32135]

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

Deletion in Cargo.lock at line 965 [32.12201]
∅:D[4.32150] → [4.32150:32184]
∅:D[4.32184] → [9.24504:24586]
∅:D[15.14422] → [9.24504:24586]
∅:D[9.24504] → [9.24504:24586]
∅:D[9.24586] → [4.32185:32261]
∅:D[4.32261] → [9.24662:24677]
∅:D[9.24662] → [9.24662:24677]
```
name = "rdrand"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
```
Replacement in Cargo.lock at line 966 [32.12201]
∅:D[33.39910] → [2.20649:20668]
```
version = "0.1.54"
```
[33.39910]
[33.39929]
```
version = "0.1.43"
```

Replacement in Cargo.lock at line 974 [32.12201]

∅:D[16.14463] → [2.20669:20750]

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

[16.14463]

[16.14544]

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

Replacement in Cargo.lock at line 979 [32.12201]
∅:D[16.14574] → [2.20751:20769]
```
version = "1.1.5"
```
[16.14574]
[16.14592]
```
version = "1.0.6"
```

Replacement in Cargo.lock at line 982 [32.12201]

∅:D[16.14674] → [2.20770:21001]

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

[16.14674]

[16.14905]

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

Replacement in Cargo.lock at line 991 [32.12201]
∅:D[16.15099] → [2.21002:21020]
```
version = "0.6.6"
```
[16.15099]
[33.40259]
```
version = "0.6.3"
```

Replacement in Cargo.lock at line 1002 [32.12201]

∅:D[33.41080] → [2.21021:21094]

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

[33.41080]

[33.41153]

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

Replacement in Cargo.lock at line 1007 [32.12201]
∅:D[33.41189] → [4.32555:32573]
```
version = "0.6.2"
```
[33.41189]
[33.41207]
```
version = "0.6.1"
```
Replacement in Cargo.lock at line 1016 [32.12201]
∅:D[33.41481] → [2.21095:21114]
```
version = "0.1.14"
```
[33.41481]
[33.41499]
```
version = "0.1.9"
```

Insertion in Cargo.lock at line 1030 [32.12201]

[16.15212]

[15.14789]

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

Replacement in Cargo.lock at line 1039 [32.12201]
∅:D[33.42024] → [4.32594:32612]
```
version = "0.4.3"
```
[33.42024]
[33.42042]
```
version = "0.4.2"
```

Replacement in Cargo.lock at line 1042 [32.12201]

∅:D[33.42124] → [4.32613:32831]

∅:D[4.32831] → [2.21115:21189]

∅:D[2.21189] → [4.32905:33048]

∅:D[6.15900] → [4.32905:33048]

∅:D[29.6990] → [4.32905:33048]

∅:D[7.6618] → [4.32905:33048]

∅:D[31.7048] → [4.32905:33048]

∅:D[4.32905] → [4.32905:33048]

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

[33.42124]

[33.42273]

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

Replacement in Cargo.lock at line 1048 [32.12201]
∅:D[33.42306] → [2.21190:21209]
```
version = "0.1.15"
```
[33.42306]
[33.42325]
```
version = "0.1.14"
```

Replacement in Cargo.lock at line 1051 [32.12201]

∅:D[33.42407] → [2.21210:21361]

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

[33.42407]

[33.42558]

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

Replacement in Cargo.lock at line 1062 [32.12201]
∅:D[33.42717] → [4.33049:33067]
```
version = "0.2.2"
```
[33.42717]
[33.42735]
```
version = "0.2.1"
```
Replacement in Cargo.lock at line 1067 [32.12201]
∅:D[33.42985] → [2.21362:21434]
∅:D[2.21434] → [4.33140:33229]
∅:D[6.16072] → [4.33140:33229]
∅:D[29.7063] → [4.33140:33229]
∅:D[7.6691] → [4.33140:33229]
∅:D[10.20192] → [4.33140:33229]
∅:D[18.11968] → [4.33140:33229]
∅:D[31.7220] → [4.33140:33229]
∅:D[4.33140] → [4.33140:33229]
```
 "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)",
```
[33.42985]
[33.43146]
```
 "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)",
```
Replacement in Cargo.lock at line 1073 [32.12201]
∅:D[33.43193] → [4.33230:33248]
```
version = "0.2.3"
```
[33.43193]
[33.43211]
```
version = "0.2.1"
```

Deletion in Cargo.lock at line 1076 [32.12201]

∅:D[33.43293] → [4.33249:33328]

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

Replacement in Cargo.lock at line 1077 [32.12201]

∅:D[33.43379] → [2.21435:21507]

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

[33.43379]

[33.43451]

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

Replacement in Cargo.lock at line 1097 [32.12201]

∅:D[33.43832] → [2.21508:21657]

∅:D[2.21657] → [4.33402:33476]

∅:D[6.16223] → [4.33402:33476]

∅:D[29.7214] → [4.33402:33476]

∅:D[7.6842] → [4.33402:33476]

∅:D[31.7371] → [4.33402:33476]

∅:D[16.15515] → [4.33402:33476]

∅:D[4.33476] → [2.21658:21732]

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

[33.43832]

[16.15663]

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

Replacement in Cargo.lock at line 1102 [32.12201]

∅:D[16.15733] → [4.33551:33626]

∅:D[4.33626] → [2.21733:21959]

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

[16.15733]

[16.15881]

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

Replacement in Cargo.lock at line 1108 [32.12201]

∅:D[16.16040] → [4.33853:33930]

∅:D[4.33930] → [2.21960:22111]

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

[16.16040]

[33.44887]

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

Replacement in Cargo.lock at line 1116 [32.12201]
∅:D[33.44917] → [2.22112:22131]
```
version = "1.0.90"
```
[33.44917]
[33.44936]
```
version = "1.0.80"
```
Replacement in Cargo.lock at line 1121 [32.12201]
∅:D[33.45036] → [2.22132:22151]
```
version = "1.0.90"
```
[33.45036]
[33.45055]
```
version = "1.0.80"
```

Replacement in Cargo.lock at line 1124 [32.12201]

∅:D[33.45137] → [4.34127:34206]

∅:D[4.34206] → [2.22152:22297]

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

[33.45137]

[33.45361]

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

Replacement in Cargo.lock at line 1131 [32.12201]
∅:D[33.45396] → [2.22298:22317]
```
version = "1.0.39"
```
[33.45396]
[33.45415]
```
version = "1.0.33"
```

Replacement in Cargo.lock at line 1136 [32.12201]

∅:D[16.16584] → [2.22318:22391]

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

[16.16584]

[33.45711]

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

Replacement in Cargo.lock at line 1141 [32.12201]
∅:D[33.45741] → [4.34446:34464]
```
version = "0.8.1"
```
[33.45741]
[33.45759]
```
version = "0.7.0"
```

Replacement in Cargo.lock at line 1144 [32.12201]

∅:D[33.45841] → [2.22392:22471]

∅:D[37.1567] → [4.34544:34617]

∅:D[2.22471] → [4.34544:34617]

∅:D[6.16966] → [4.34544:34617]

∅:D[10.20854] → [4.34544:34617]

∅:D[18.12630] → [4.34544:34617]

∅:D[13.5918] → [4.34544:34617]

∅:D[31.7960] → [4.34544:34617]

∅:D[4.34544] → [4.34544:34617]

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

[33.45841]

[33.46070]

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

Deletion in Cargo.lock at line 1148 [32.12201]

∅:D[33.46146] → [4.34618:34697]

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

Replacement in Cargo.lock at line 1152 [32.12201]
∅:D[33.46175] → [4.34698:34716]
```
version = "0.8.0"
```
[33.46175]
[33.46193]
```
version = "0.7.1"
```

Replacement in Cargo.lock at line 1155 [32.12201]

∅:D[33.46275] → [2.22472:22551]

∅:D[37.1647] → [4.34796:34869]

∅:D[2.22551] → [4.34796:34869]

∅:D[6.17046] → [4.34796:34869]

∅:D[10.20934] → [4.34796:34869]

∅:D[18.12710] → [4.34796:34869]

∅:D[13.5998] → [4.34796:34869]

∅:D[31.8040] → [4.34796:34869]

∅:D[4.34796] → [4.34796:34869]

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

[33.46275]

[33.46504]

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

Deletion in Cargo.lock at line 1159 [32.12201]

∅:D[33.46580] → [4.34870:34949]

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

Replacement in Cargo.lock at line 1163 [32.12201]
∅:D[33.46609] → [4.34950:34968]
```
version = "0.8.1"
```
[33.46609]
[33.46627]
```
version = "0.7.3"
```

Replacement in Cargo.lock at line 1166 [32.12201]

∅:D[33.46709] → [2.22552:22631]

∅:D[37.1727] → [4.35048:35198]

∅:D[2.22631] → [4.35048:35198]

∅:D[6.17126] → [4.35048:35198]

∅:D[10.21014] → [4.35048:35198]

∅:D[18.12790] → [4.35048:35198]

∅:D[13.6078] → [4.35048:35198]

∅:D[31.8120] → [4.35048:35198]

∅:D[4.35048] → [4.35048:35198]

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

[33.46709]

[33.46938]

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

Deletion in Cargo.lock at line 1170 [32.12201]

∅:D[33.47011] → [4.35199:35278]

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

Replacement in Cargo.lock at line 1174 [32.12201]
∅:D[33.47047] → [2.22632:22650]
```
version = "0.1.8"
```
[33.47047]
[33.47065]
```
version = "0.1.6"
```

Replacement in Cargo.lock at line 1177 [32.12201]

∅:D[33.47147] → [2.22651:22799]

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

[33.47147]

[33.47294]

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

Replacement in Cargo.lock at line 1188 [32.12201]
∅:D[33.47438] → [4.35446:35464]
```
version = "0.4.2"
```
[33.47438]
[33.47456]
```
version = "0.4.1"
```
Replacement in Cargo.lock at line 1193 [32.12201]
∅:D[33.47552] → [2.22800:22818]
```
version = "0.6.9"
```
[33.47552]
[33.47570]
```
version = "0.6.6"
```

Insertion in Cargo.lock at line 1195 [32.12201]

[33.47635]

[33.47732]

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

Replacement in Cargo.lock at line 1204 [32.12201]

∅:D[33.47862] → [2.22819:23118]

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

[33.47862]

[33.48161]

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

Replacement in Cargo.lock at line 1217 [32.12201]
∅:D[33.48316] → [4.35638:35656]
```
version = "0.1.3"
```
[33.48316]
[33.48334]
```
version = "0.1.2"
```

Replacement in Cargo.lock at line 1225 [32.12201]

∅:D[33.48534] → [2.23119:23285]

∅:D[37.1835] → [4.35657:35735]

∅:D[2.23285] → [4.35657:35735]

∅:D[6.17648] → [4.35657:35735]

∅:D[10.21365] → [4.35657:35735]

∅:D[18.13239] → [4.35657:35735]

∅:D[13.6284] → [4.35657:35735]

∅:D[31.8544] → [4.35657:35735]

∅:D[33.48700] → [4.35657:35735]

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

[33.48534]

[33.48778]

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

Replacement in Cargo.lock at line 1229 [32.12201]

∅:D[33.48861] → [2.23286:23359]

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

[33.48861]

[33.48934]

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

Replacement in Cargo.lock at line 1239 [32.12201]

∅:D[33.49252] → [4.35810:36048]

∅:D[4.36048] → [2.23360:23433]

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

[33.49252]

[33.49563]

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

Replacement in Cargo.lock at line 1253 [32.12201]
∅:D[33.49805] → [2.23434:23452]
∅:D[2.23452] → [4.36122:36234]
∅:D[33.49823] → [4.36122:36234]
```
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "subtle"
version = "1.0.0"
```
[33.49805]
[33.49823]
```
version = "0.7.0"
```
Replacement in Cargo.lock at line 1268 [32.12201]
∅:D[33.50268] → [2.23453:23473]
```
version = "0.15.30"
```
[33.50268]
[33.50288]
```
version = "0.15.22"
```

Replacement in Cargo.lock at line 1271 [32.12201]

∅:D[33.50370] → [4.36256:36335]

∅:D[4.36335] → [2.23474:23547]

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

[33.50370]

[33.50522]

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

Replacement in Cargo.lock at line 1289 [32.12201]

∅:D[33.50947] → [4.36409:36488]

∅:D[4.36488] → [2.23548:23693]

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

[33.50947]

[33.51171]

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

Replacement in Cargo.lock at line 1297 [32.12201]
∅:D[33.51282] → [2.23694:23712]
```
version = "3.0.7"
```
[33.51282]
[33.51300]
```
version = "3.0.5"
```

Replacement in Cargo.lock at line 1300 [32.12201]

∅:D[33.51382] → [2.23713:23858]

∅:D[2.23858] → [4.36725:36796]

∅:D[6.17981] → [4.36725:36796]

∅:D[29.7746] → [4.36725:36796]

∅:D[7.7601] → [4.36725:36796]

∅:D[10.21625] → [4.36725:36796]

∅:D[18.13499] → [4.36725:36796]

∅:D[31.8877] → [4.36725:36796]

∅:D[4.36725] → [4.36725:36796]

∅:D[4.36796] → [2.23859:23940]

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

[33.51382]

[33.51679]

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

Replacement in Cargo.lock at line 1305 [32.12201]

∅:D[33.51760] → [2.23941:24014]

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

[33.51760]

[33.51833]

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

Replacement in Cargo.lock at line 1310 [32.12201]
∅:D[33.51865] → [4.36878:36896]
```
version = "0.4.1"
```
[33.51865]
[33.51883]
```
version = "0.4.0"
```

Replacement in Cargo.lock at line 1315 [32.12201]

∅:D[33.52106] → [4.36897:36969]

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

[33.52106]

[16.17839]

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

Replacement in Cargo.lock at line 1331 [32.12201]

∅:D[33.52519] → [2.24015:24168]

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

[33.52519]

[33.52672]

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

Replacement in Cargo.lock at line 1338 [32.12201]
∅:D[33.52785] → [2.24169:24188]
```
version = "0.11.0"
```
[33.52785]
[33.52804]
```
version = "0.10.0"
```

Replacement in Cargo.lock at line 1349 [32.12201]

∅:D[16.18340] → [2.24189:24267]

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

[16.18340]

[33.52966]

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

Replacement in Cargo.lock at line 1354 [32.12201]
∅:D[33.53210] → [4.37124:37143]
```
version = "0.1.42"
```
[33.53210]
[33.53229]
```
version = "0.1.40"
```

Replacement in Cargo.lock at line 1357 [32.12201]

∅:D[33.53311] → [2.24268:24494]

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

[33.53311]

[33.53537]

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

Replacement in Cargo.lock at line 1364 [32.12201]
∅:D[33.53567] → [2.24495:24514]
```
version = "0.1.18"
```
[33.53567]
[33.53586]
```
version = "0.1.13"
```

Replacement in Cargo.lock at line 1367 [32.12201]

∅:D[33.53668] → [2.24515:24663]

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

[33.53668]

[33.53816]

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

Replacement in Cargo.lock at line 1370 [32.12201]

∅:D[33.53887] → [2.24664:24740]

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

[33.53887]

[33.53962]

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

Replacement in Cargo.lock at line 1372 [32.12201]

∅:D[33.54040] → [2.24741:25217]

∅:D[2.25217] → [4.37783:37859]

∅:D[6.18773] → [4.37783:37859]

∅:D[7.7919] → [4.37783:37859]

∅:D[10.22344] → [4.37783:37859]

∅:D[18.14217] → [4.37783:37859]

∅:D[31.9670] → [4.37783:37859]

∅:D[4.37783] → [4.37783:37859]

∅:D[4.37859] → [2.25218:25302]

∅:D[2.25302] → [4.37943:38022]

∅:D[6.18858] → [4.37943:38022]

∅:D[10.22429] → [4.37943:38022]

∅:D[18.14302] → [4.37943:38022]

∅:D[31.9755] → [4.37943:38022]

∅:D[4.37943] → [4.37943:38022]

∅:D[4.38022] → [2.25303:25386]

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

[33.54040]

[16.19073]

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

Replacement in Cargo.lock at line 1381 [32.12201]

∅:D[16.19149] → [4.38023:38099]

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

[16.19149]

[16.19225]

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

Replacement in Cargo.lock at line 1389 [32.12201]

∅:D[16.19363] → [2.25387:25462]

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

[16.19363]

[33.55024]

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

Replacement in Cargo.lock at line 1397 [32.12201]

∅:D[33.55160] → [2.25463:25687]

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

[33.55160]

[33.55384]

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

Replacement in Cargo.lock at line 1404 [32.12201]
∅:D[33.55429] → [2.25688:25706]
```
version = "0.1.6"
```
[33.55429]
[33.55447]
```
version = "0.1.4"
```

Replacement in Cargo.lock at line 1407 [32.12201]

∅:D[33.55529] → [2.25707:25863]

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

[33.55529]

[33.55685]

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

Replacement in Cargo.lock at line 1413 [32.12201]
∅:D[33.55724] → [2.25864:25882]
```
version = "0.1.7"
```
[33.55724]
[33.55742]
```
version = "0.1.5"
```

Replacement in Cargo.lock at line 1416 [32.12201]

∅:D[33.55824] → [4.38278:38360]

∅:D[4.38360] → [2.25883:25958]

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

[33.55824]

[33.55899]

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

Replacement in Cargo.lock at line 1421 [32.12201]
∅:D[33.55932] → [2.25959:25977]
```
version = "0.1.6"
```
[33.55932]
[33.55950]
```
version = "0.1.4"
```

Replacement in Cargo.lock at line 1424 [32.12201]

∅:D[33.56032] → [2.25978:26213]

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

[33.56032]

[33.56266]

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

Replacement in Cargo.lock at line 1431 [32.12201]
∅:D[33.56299] → [2.26214:26233]
```
version = "0.1.12"
```
[33.56299]
[33.56318]
```
version = "0.1.10"
```

Replacement in Cargo.lock at line 1434 [32.12201]

∅:D[33.56400] → [2.26234:26382]

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

[33.56400]

[16.19690]

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

Replacement in Cargo.lock at line 1441 [32.12201]
∅:D[33.56656] → [2.26383:26401]
```
version = "0.1.9"
```
[33.56656]
[33.56674]
```
version = "0.1.7"
```

Replacement in Cargo.lock at line 1444 [32.12201]

∅:D[33.56756] → [4.38580:38662]

∅:D[4.38662] → [2.26402:26555]

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

[33.56756]

[16.19941]

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

Replacement in Cargo.lock at line 1449 [32.12201]

∅:D[33.57132] → [2.26556:26632]

∅:D[37.2082] → [4.38738:38887]

∅:D[2.26632] → [4.38738:38887]

∅:D[6.19476] → [4.38738:38887]

∅:D[10.22900] → [4.38738:38887]

∅:D[18.14772] → [4.38738:38887]

∅:D[13.6529] → [4.38738:38887]

∅:D[31.10374] → [4.38738:38887]

∅:D[4.38738] → [4.38738:38887]

∅:D[4.38887] → [2.26633:26867]

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

[33.57132]

[33.57513]

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

Replacement in Cargo.lock at line 1461 [32.12201]

∅:D[33.57650] → [2.26868:27015]

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

[33.57650]

[33.57797]

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

Replacement in Cargo.lock at line 1465 [32.12201]

∅:D[33.57942] → [2.27016:27404]

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

[33.57942]

[4.39434]

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

Deletion in Cargo.lock at line 1473 [32.12201]
∅:D[4.39449] → [4.39449:39469]
∅:D[4.39449] → [4.39449:39469]
∅:D[4.39469] → [2.27405:27423]
∅:D[2.27423] → [4.39487:39569]
∅:D[6.19881] → [4.39487:39569]
∅:D[7.8321] → [4.39487:39569]
∅:D[10.23382] → [4.39487:39569]
∅:D[18.15177] → [4.39487:39569]
∅:D[31.10856] → [4.39487:39569]
∅:D[4.39487] → [4.39487:39569]
∅:D[4.39569] → [2.27424:27569]
∅:D[2.27569] → [33.58330:58345]
∅:D[4.39644] → [33.58330:58345]
∅:D[33.58330] → [33.58330:58345]
```
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)",
]
[[package]]
```
Replacement in Cargo.lock at line 1474 [32.12201]
∅:D[33.58364] → [4.39645:39663]
```
version = "0.1.3"
```
[33.58364]
[33.58382]
```
version = "0.1.2"
```

Replacement in Cargo.lock at line 1477 [32.12201]

∅:D[33.58464] → [2.27570:27718]

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

[33.58464]

[33.58612]

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

Replacement in Cargo.lock at line 1481 [32.12201]

∅:D[33.58755] → [2.27719:27875]

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

[33.58755]

[33.58911]

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

Replacement in Cargo.lock at line 1487 [32.12201]
∅:D[33.58952] → [2.27876:27895]
```
version = "0.1.13"
```
[33.58952]
[33.58970]
```
version = "0.1.9"
```

Replacement in Cargo.lock at line 1490 [32.12201]

∅:D[33.59052] → [2.27896:28060]

∅:D[2.28060] → [4.40083:40165]

∅:D[6.20375] → [4.40083:40165]

∅:D[10.23795] → [4.40083:40165]

∅:D[18.15597] → [4.40083:40165]

∅:D[31.11343] → [4.40083:40165]

∅:D[4.40083] → [4.40083:40165]

∅:D[4.40165] → [2.28061:28136]

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

[33.59052]

[16.20603]

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

Replacement in Cargo.lock at line 1494 [32.12201]

∅:D[16.20673] → [2.28137:28213]

∅:D[37.2159] → [4.40241:40383]

∅:D[2.28213] → [4.40241:40383]

∅:D[6.20451] → [4.40241:40383]

∅:D[10.23872] → [4.40241:40383]

∅:D[18.15673] → [4.40241:40383]

∅:D[13.6605] → [4.40241:40383]

∅:D[31.11420] → [4.40241:40383]

∅:D[4.40241] → [4.40241:40383]

∅:D[4.40383] → [2.28214:28295]

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

[16.20673]

[33.59588]

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

Replacement in Cargo.lock at line 1501 [32.12201]
∅:D[33.59624] → [4.40465:40484]
```
version = "0.2.10"
```
[33.59624]
[33.59642]
```
version = "0.2.8"
```

Replacement in Cargo.lock at line 1504 [32.12201]

∅:D[33.59724] → [4.40485:40567]

∅:D[4.40567] → [2.28296:28371]

∅:D[2.28371] → [4.40568:40639]

∅:D[33.59881] → [4.40568:40639]

∅:D[4.40639] → [2.28372:28453]

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

[33.59724]

[33.60033]

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

Replacement in Cargo.lock at line 1512 [32.12201]
∅:D[33.60067] → [4.40721:40739]
```
version = "0.2.1"
```
[33.60067]
[33.60085]
```
version = "0.2.0"
```

Replacement in Cargo.lock at line 1515 [32.12201]

∅:D[33.60167] → [2.28454:28529]

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

[33.60167]

[33.60242]

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

Replacement in Cargo.lock at line 1517 [32.12201]

∅:D[33.60319] → [2.28530:28825]

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

[33.60319]

[33.60395]

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

Replacement in Cargo.lock at line 1525 [32.12201]

∅:D[33.60529] → [2.28826:28974]

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

[33.60529]

[16.20941]

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

Replacement in Cargo.lock at line 1530 [32.12201]

∅:D[33.60896] → [2.28975:29131]

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

[33.60896]

[33.61052]

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

Replacement in Cargo.lock at line 1536 [32.12201]
∅:D[33.61086] → [4.40974:40992]
```
version = "0.2.5"
```
[33.61086]
[33.61104]
```
version = "0.2.4"
```

Replacement in Cargo.lock at line 1539 [32.12201]

∅:D[33.61186] → [2.29132:29280]

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

[33.61186]

[33.61334]

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

Replacement in Cargo.lock at line 1542 [32.12201]

∅:D[33.61406] → [2.29281:29353]

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

[33.61406]

[16.21258]

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

Replacement in Cargo.lock at line 1547 [32.12201]

∅:D[16.21407] → [2.29354:29510]

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

[16.21407]

[33.61927]

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

Replacement in Cargo.lock at line 1553 [32.12201]
∅:D[33.61962] → [4.41223:41241]
```
version = "1.0.0"
```
[33.61962]
[33.61980]
```
version = "0.2.0"
```

Replacement in Cargo.lock at line 1556 [32.12201]

∅:D[33.62062] → [2.29511:29584]

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

[33.62062]

[33.62135]

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

Replacement in Cargo.lock at line 1558 [32.12201]

∅:D[33.62214] → [2.29585:29660]

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

[33.62214]

[33.62289]

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

Insertion in Cargo.lock at line 1560 [32.12201]

[33.62360]

[33.62504]

 "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 1563 [32.12201]

∅:D[33.62581] → [2.29661:29738]

∅:D[2.29738] → [4.41319:41390]

∅:D[6.21215] → [4.41319:41390]

∅:D[10.24414] → [4.41319:41390]

∅:D[18.16215] → [4.41319:41390]

∅:D[31.12184] → [4.41319:41390]

∅:D[4.41319] → [4.41319:41390]

∅:D[4.41390] → [2.29739:29812]

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

[33.62581]

[33.62802]

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

Replacement in Cargo.lock at line 1567 [32.12201]

∅:D[33.62880] → [2.29813:29889]

∅:D[2.29889] → [4.41540:41784]

∅:D[6.21366] → [4.41540:41784]

∅:D[10.24565] → [4.41540:41784]

∅:D[18.16366] → [4.41540:41784]

∅:D[31.12335] → [4.41540:41784]

∅:D[4.41540] → [4.41540:41784]

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

[33.62880]

[16.21637]

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

Replacement in Cargo.lock at line 1573 [32.12201]

∅:D[16.21713] → [4.41785:41865]

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

[16.21713]

[33.63430]

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

Replacement in Cargo.lock at line 1578 [32.12201]
∅:D[33.63459] → [2.29890:29908]
```
version = "0.5.0"
```
[33.63459]
[33.63478]
```
version = "0.4.10"
```

Replacement in Cargo.lock at line 1581 [32.12201]

∅:D[33.63560] → [2.29909:29982]

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

[33.63560]

[33.63633]

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

Replacement in Cargo.lock at line 1586 [32.12201]
∅:D[33.63673] → [4.41940:41958]
```
version = "0.6.3"
```
[33.63673]
[33.63691]
```
version = "0.4.3"
```

Replacement in Cargo.lock at line 1589 [32.12201]

∅:D[33.63773] → [4.41959:42109]

∅:D[4.42109] → [2.29983:30058]

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

[33.63773]

[33.64003]

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

Replacement in Cargo.lock at line 1593 [32.12201]

∅:D[33.64074] → [2.30059:30137]

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

[33.64074]

[16.21812]

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

Replacement in Cargo.lock at line 1595 [32.12201]

∅:D[16.21882] → [4.42110:42181]

∅:D[4.42181] → [2.30138:30213]

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

[16.21882]

[33.64368]

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

Replacement in Cargo.lock at line 1598 [32.12201]

∅:D[33.64442] → [2.30214:30451]

∅:D[2.30451] → [4.42494:42649]

∅:D[6.21772] → [4.42494:42649]

∅:D[10.24951] → [4.42494:42649]

∅:D[18.16752] → [4.42494:42649]

∅:D[31.12721] → [4.42494:42649]

∅:D[4.42494] → [4.42494:42649]

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

[33.64442]

[16.22118]

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

Replacement in Cargo.lock at line 1609 [32.12201]
∅:D[33.65022] → [4.42650:42669]
```
version = "0.10.3"
```
[33.65022]
[33.65040]
```
version = "0.9.1"
```

Replacement in Cargo.lock at line 1612 [32.12201]

∅:D[33.65122] → [2.30452:30525]

∅:D[2.30525] → [4.42670:42744]

∅:D[6.21846] → [4.42670:42744]

∅:D[29.8630] → [4.42670:42744]

∅:D[7.9077] → [4.42670:42744]

∅:D[31.12795] → [4.42670:42744]

∅:D[33.65195] → [4.42670:42744]

∅:D[4.42744] → [2.30526:30601]

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

[33.65122]

[16.22265]

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

Replacement in Cargo.lock at line 1616 [32.12201]

∅:D[16.22340] → [2.30602:30680]

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

[16.22340]

[16.22418]

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

Replacement in Cargo.lock at line 1618 [32.12201]

∅:D[16.22488] → [2.30681:30757]

∅:D[2.30757] → [4.42745:42823]

∅:D[6.22002] → [4.42745:42823]

∅:D[7.9154] → [4.42745:42823]

∅:D[33.65648] → [4.42745:42823]

∅:D[4.42823] → [2.30758:30906]

∅:D[2.30906] → [4.42971:43053]

∅:D[6.22151] → [4.42971:43053]

∅:D[7.9228] → [4.42971:43053]

∅:D[10.25179] → [4.42971:43053]

∅:D[18.16980] → [4.42971:43053]

∅:D[31.13023] → [4.42971:43053]

∅:D[4.42971] → [4.42971:43053]

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

[16.22488]

[33.65956]

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

Replacement in Cargo.lock at line 1632 [32.12201]
∅:D[33.66103] → [4.43054:43072]
```
version = "0.3.2"
```
[33.66103]
[33.66121]
```
version = "0.2.2"
```
Deletion in Cargo.lock at line 1634 [32.12201]
∅:D[33.66186] → [4.43073:43090]
∅:D[4.43090] → [2.30907:30980]
∅:D[2.30980] → [4.43163:43165]
∅:D[6.22225] → [4.43163:43165]
∅:D[29.8704] → [4.43163:43165]
∅:D[7.9302] → [4.43163:43165]
∅:D[31.13097] → [4.43163:43165]
∅:D[4.43163] → [4.43163:43165]
```
dependencies = [
 "cfg-if 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
]
```
Replacement in Cargo.lock at line 1655 [32.12201]
∅:D[33.66669] → [4.43166:43184]
```
version = "0.1.8"
```
[33.66669]
[33.66687]
```
version = "0.1.7"
```
Deletion in Cargo.lock at line 1657 [32.12201]
∅:D[33.66752] → [4.43185:43202]
∅:D[4.43202] → [2.30981:31056]
∅:D[37.2461] → [4.43277:43279]
∅:D[2.31056] → [4.43277:43279]
∅:D[6.22301] → [4.43277:43279]
∅:D[10.25255] → [4.43277:43279]
∅:D[18.17056] → [4.43277:43279]
∅:D[13.6907] → [4.43277:43279]
∅:D[31.13173] → [4.43277:43279]
∅:D[4.43277] → [4.43277:43279]
```
dependencies = [
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
]
```

Insertion in Cargo.lock at line 1674 [32.12201]

[13.7115]

[33.67325]

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 1693 [32.12201]
∅:D[33.67696] → [4.43280:43298]
```
version = "0.7.5"
```
[33.67696]
[16.22772]
```
version = "0.7.4"
```

Insertion in Cargo.lock at line 1709 [32.12201]

[33.68055]

[33.68284]

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 1726 [32.12201]

∅:D[33.68476] → [2.31057:31132]

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

[33.68476]

[16.22890]

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

Replacement in Cargo.lock at line 1743 [32.12201]
∅:D[33.68955] → [2.31133:31151]
```
version = "0.3.7"
```
[33.68955]
[33.68973]
```
version = "0.3.6"
```
Replacement in Cargo.lock at line 1762 [32.12201]
∅:D[16.22982] → [4.43299:43317]
```
version = "0.1.2"
```
[16.22982]
[16.23000]
```
version = "0.1.1"
```

Replacement in Cargo.lock at line 1765 [32.12201]

∅:D[16.23082] → [2.31152:31225]

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

[16.23082]

[16.23155]

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

Replacement in Cargo.lock at line 1778 [32.12201]

∅:D[16.23303] → [2.31226:31299]

∅:D[2.31299] → [4.43318:43396]

∅:D[16.23376] → [4.43318:43396]

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

[16.23303]

[16.23454]

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

Replacement in Cargo.lock at line 1787 [32.12201]

∅:D[33.70251] → [2.31300:31373]

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

[33.70251]

[33.70324]

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

Replacement in Cargo.lock at line 1795 [32.12201]

∅:D[33.70456] → [2.31374:31447]

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

[33.70456]

[33.70529]

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

Replacement in Cargo.lock at line 1814 [32.12201]
∅:D[33.71090] → [4.43397:43547]
∅:D[19.35238] → [33.71240:71277]
∅:D[4.43547] → [33.71240:71277]
∅:D[35.24367] → [33.71240:71277]
∅:D[38.8622] → [33.71240:71277]
∅:D[36.17781] → [33.71240:71277]
∅:D[9.35153] → [33.71240:71277]
∅:D[39.15962] → [33.71240:71277]
∅:D[3.52912] → [33.71240:71277]
∅:D[20.27760] → [33.71240:71277]
∅:D[40.12204] → [33.71240:71277]
∅:D[41.9725] → [33.71240:71277]
∅:D[17.21034] → [33.71240:71277]
∅:D[15.24496] → [33.71240:71277]
∅:D[42.12614] → [33.71240:71277]
∅:D[43.12950] → [33.71240:71277]
∅:D[33.71240] → [33.71240:71277]
∅:D[33.71277] → [4.43548:43567]
∅:D[19.35258] → [33.71296:71378]
∅:D[4.43567] → [33.71296:71378]
∅:D[35.24387] → [33.71296:71378]
∅:D[9.35173] → [33.71296:71378]
∅:D[3.52932] → [33.71296:71378]
∅:D[20.27780] → [33.71296:71378]
∅:D[15.24516] → [33.71296:71378]
∅:D[33.71296] → [33.71296:71378]
∅:D[33.71378] → [4.43568:43715]
∅:D[19.35406] → [33.71524:71597]
∅:D[4.43715] → [33.71524:71597]
∅:D[35.24534] → [33.71524:71597]
∅:D[9.35321] → [33.71524:71597]
∅:D[3.53080] → [33.71524:71597]
∅:D[20.27927] → [33.71524:71597]
∅:D[15.24663] → [33.71524:71597]
∅:D[33.71524] → [33.71524:71597]
∅:D[33.71597] → [4.43716:44223]
```
 "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)",
]
[[package]]
name = "xmpp-parsers"
version = "0.12.2"
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)",
 "try_from 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
```
[33.71090]
[2.31448]
```
 "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)",
```
Replacement in Cargo.lock at line 1820 [32.12201]
∅:D[2.31485] → [2.31485:31504]
```
version = "0.13.1"
```
[2.31485]
[2.31504]
```
version = "0.11.1"
```

Replacement in Cargo.lock at line 1823 [32.12201]

∅:D[2.31586] → [2.31586: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)",

[2.31586]

[2.31733]

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

Replacement in Cargo.lock at line 1826 [32.12201]

∅:D[2.31806] → [2.31806:32238]

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

[2.31806]

[33.72103]

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

Replacement in Cargo.lock at line 1836 [32.12201]

∅:D[33.72117] → [4.44224:44379]

∅:D[4.44379] → [2.32239:32394]

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

[33.72117]

[33.72272]

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

Replacement in Cargo.lock at line 1838 [32.12201]

∅:D[33.72425] → [2.32395:32547]

∅:D[2.32547] → [4.44531:44683]

∅:D[4.44531] → [4.44531:44683]

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

[33.72425]

[33.72878]

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

Replacement in Cargo.lock at line 1842 [32.12201]

∅:D[33.73026] → [4.44684:44834]

∅:D[4.44834] → [2.32548:32701]

∅:D[2.32701] → [4.44987:45294]

∅:D[6.22930] → [4.44987:45294]

∅:D[10.25566] → [4.44987:45294]

∅:D[18.17685] → [4.44987:45294]

∅:D[31.13484] → [4.44987:45294]

∅:D[4.44987] → [4.44987:45294]

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

[33.73026]

[33.73636]

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

Replacement in Cargo.lock at line 1847 [32.12201]

∅:D[33.73787] → [4.45295:45444]

∅:D[4.45444] → [2.32702:32857]

∅:D[37.2774] → [4.45599:46060]

∅:D[2.32857] → [4.45599:46060]

∅:D[6.23086] → [4.45599:46060]

∅:D[10.25722] → [4.45599:46060]

∅:D[18.17841] → [4.45599:46060]

∅:D[13.7538] → [4.45599:46060]

∅:D[31.13640] → [4.45599:46060]

∅:D[4.45599] → [4.45599:46060]

∅:D[4.46060] → [2.32858:33007]

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

[33.73787]

[33.74545]

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

Replacement in Cargo.lock at line 1853 [32.12201]

∅:D[33.74692] → [2.33008:33303]

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

[33.74692]

[33.74987]

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

Replacement in Cargo.lock at line 1856 [32.12201]

∅:D[33.75136] → [2.33304:33452]

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

[33.75136]

[33.75284]

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

Insertion in Cargo.lock at line 1858 [32.12201]

[33.75435]

[33.75594]

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

Replacement in Cargo.lock at line 1861 [32.12201]

∅:D[33.75914] → [2.33453:33611]

∅:D[2.33611] → [4.46678:46836]

∅:D[6.24003] → [4.46678:46836]

∅:D[10.26028] → [4.46678:46836]

∅:D[18.18459] → [4.46678:46836]

∅:D[31.14245] → [4.46678:46836]

∅:D[4.46678] → [4.46678:46836]

∅:D[4.46836] → [2.33612:33770]

∅:D[2.33770] → [4.46836:47147]

∅:D[10.26187] → [4.46836:47147]

∅:D[31.14404] → [4.46836:47147]

∅:D[4.46836] → [4.46836:47147]

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

[33.75914]

[33.76695]

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

Replacement in Cargo.lock at line 1867 [32.12201]

∅:D[33.76850] → [4.47148:47297]

∅:D[4.47297] → [2.33771:34079]

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

[33.76850]

[33.77462]

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

Replacement in Cargo.lock at line 1872 [32.12201]

∅:D[33.77616] → [4.47453:47760]

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

[33.77616]

[33.77923]

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

Deletion in Cargo.lock at line 1878 [32.12201]

∅:D[33.78540] → [4.47761:47917]

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

Replacement in Cargo.lock at line 1881 [32.12201]

∅:D[33.79005] → [2.34080:34231]

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

[33.79005]

[33.79156]

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

Replacement in Cargo.lock at line 1883 [32.12201]

∅:D[33.79314] → [4.47918:48075]

∅:D[4.48075] → [2.34232:34378]

∅:D[2.34378] → [4.48221:48368]

∅:D[6.24459] → [4.48221:48368]

∅:D[7.10915] → [4.48221:48368]

∅:D[4.48221] → [4.48221:48368]

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

[33.79314]

[33.79616]

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

Replacement in Cargo.lock at line 1886 [32.12201]

∅:D[33.79767] → [2.34379:34527]

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

[33.79767]

[33.79915]

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

Replacement in Cargo.lock at line 1889 [32.12201]

∅:D[16.25390] → [2.34528:34678]

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

[16.25390]

[33.80368]

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

Replacement in Cargo.lock at line 1895 [32.12201]

∅:D[33.81112] → [4.48669:48815]

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

[33.81112]

[33.81258]

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

Replacement in Cargo.lock at line 1898 [32.12201]

∅:D[33.81562] → [2.34679:34833]

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

[33.81562]

[16.25847]

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

Replacement in Cargo.lock at line 1900 [32.12201]

∅:D[16.25998] → [2.34834:35140]

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

[16.25998]

[16.26147]

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

Replacement in Cargo.lock at line 1904 [32.12201]

∅:D[16.26444] → [2.35141:35293]

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

[16.26444]

[33.82622]

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

Replacement in Cargo.lock at line 1906 [32.12201]

∅:D[33.82768] → [4.48965:49119]

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

[33.82768]

[33.82922]

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

Replacement in Cargo.lock at line 1908 [32.12201]

∅:D[33.83072] → [2.35294:35443]

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

[33.83072]

[33.83221]

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

Replacement in Cargo.lock at line 1910 [32.12201]

∅:D[33.83373] → [4.49270:49421]

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

[33.83373]

[33.83523]

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

Replacement in Cargo.lock at line 1916 [32.12201]

∅:D[33.84268] → [2.35444:35608]

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

[33.84268]

[16.26595]

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

Replacement in Cargo.lock at line 1920 [32.12201]

∅:D[33.84890] → [2.35609:35761]

∅:D[37.3549] → [4.49573:49728]

∅:D[2.35761] → [4.49573:49728]

∅:D[6.25841] → [4.49573:49728]

∅:D[10.27415] → [4.49573:49728]

∅:D[18.19686] → [4.49573:49728]

∅:D[13.8312] → [4.49573:49728]

∅:D[31.15785] → [4.49573:49728]

∅:D[4.49573] → [4.49573:49728]

∅:D[4.49728] → [2.35762:35914]

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

[33.84890]

[33.85193]

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

Replacement in Cargo.lock at line 1923 [32.12201]

∅:D[33.85349] → [2.35915:36070]

"checksum openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)" = "33c86834957dd5b915623e94f2f4ab2c70dd8f6b70679824155d5ae21dbd495d"

[33.85349]

[16.26746]

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

Replacement in Cargo.lock at line 1925 [32.12201]

∅:D[16.26899] → [4.50037:50499]

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

[16.26899]

[33.85970]

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

Replacement in Cargo.lock at line 1928 [32.12201]

∅:D[33.86129] → [4.50500:51113]

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

[33.86129]

[33.86742]

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

Replacement in Cargo.lock at line 1934 [32.12201]

∅:D[33.87055] → [4.51114:51269]

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

[33.87055]

[33.87210]

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

Replacement in Cargo.lock at line 1936 [32.12201]

∅:D[33.87364] → [2.36071:36224]

"checksum quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)" = "22fcc48ecef4609b243e8c01ff4695d08ee0fc9d5bdbc54630e1a5fe8bb40953"

[33.87364]

[33.87517]

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

Replacement in Cargo.lock at line 1938 [32.12201]

∅:D[33.87666] → [2.36225:36374]

∅:D[2.36374] → [4.51573:52325]

∅:D[4.51573] → [4.51573:52325]

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

[33.87666]

[16.27508]

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

Replacement in Cargo.lock at line 1947 [32.12201]

∅:D[16.27811] → [4.52326:52480]

∅:D[4.52480] → [2.36375:36676]

∅:D[2.36676] → [4.52631:52936]

∅:D[6.26606] → [4.52631:52936]

∅:D[10.28030] → [4.52631:52936]

∅:D[18.20301] → [4.52631:52936]

∅:D[31.16550] → [4.52631:52936]

∅:D[16.27962] → [4.52631:52936]

∅:D[4.52936] → [2.36677:36834]

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

[16.27811]

[33.89481]

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

Replacement in Cargo.lock at line 1951 [32.12201]

∅:D[33.89637] → [2.36835:37138]

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

[33.89637]

[33.89940]

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

Replacement in Cargo.lock at line 1954 [32.12201]

∅:D[33.90097] → [4.53398:53552]

∅:D[4.53552] → [2.37139:37297]

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

[33.90097]

[33.90408]

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

Replacement in Cargo.lock at line 1958 [32.12201]

∅:D[16.28726] → [4.53711:53858]

∅:D[4.53858] → [2.37298:37450]

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

[16.28726]

[33.91159]

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

Replacement in Cargo.lock at line 1962 [32.12201]

∅:D[33.91312] → [4.53859:54185]

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

[33.91312]

[33.91638]

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

Replacement in Cargo.lock at line 1966 [32.12201]

∅:D[33.91943] → [2.37451:37910]

∅:D[2.37910] → [4.54645:55087]

∅:D[6.27368] → [4.54645:55087]

∅:D[10.28792] → [4.54645:55087]

∅:D[18.21063] → [4.54645:55087]

∅:D[31.17312] → [4.54645:55087]

∅:D[4.54645] → [4.54645:55087]

∅:D[4.55087] → [2.37911:38065]

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

[33.91943]

[33.92998]

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

Replacement in Cargo.lock at line 1974 [32.12201]

∅:D[33.93150] → [4.55242:55389]

∅:D[4.55389] → [2.38066:38217]

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

[33.93150]

[33.93448]

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

Replacement in Cargo.lock at line 1978 [32.12201]

∅:D[33.93759] → [4.55541:55690]

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

[33.93759]

[33.93908]

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

Replacement in Cargo.lock at line 1982 [32.12201]

∅:D[33.94388] → [2.38218:38367]

∅:D[2.38367] → [4.55691:55840]

∅:D[33.94537] → [4.55691:55840]

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

[33.94388]

[33.94537]

"checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550"

Replacement in Cargo.lock at line 1984 [32.12201]

∅:D[33.94685] → [2.38368:38516]

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

[33.94685]

[33.94833]

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

Replacement in Cargo.lock at line 1987 [32.12201]

∅:D[16.29644] → [2.38517:38668]

∅:D[37.4159] → [4.56141:56291]

∅:D[2.38668] → [4.56141:56291]

∅:D[6.27976] → [4.56141:56291]

∅:D[10.29400] → [4.56141:56291]

∅:D[18.21671] → [4.56141:56291]

∅:D[13.8922] → [4.56141:56291]

∅:D[31.17920] → [4.56141:56291]

∅:D[4.56141] → [4.56141:56291]

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

[16.29644]

[16.29796]

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

Replacement in Cargo.lock at line 1991 [32.12201]

∅:D[33.95741] → [2.38669:38821]

"checksum textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"

[33.95741]

[16.29949]

"checksum textwrap 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "307686869c93e71f94da64286f9a9524c0f308a9e1c87a583de8e9c9039ad3f6"

Replacement in Cargo.lock at line 1993 [32.12201]

∅:D[16.30104] → [4.56292:56440]

∅:D[4.56440] → [2.38822:38971]

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

[16.30104]

[16.30254]

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

Replacement in Cargo.lock at line 1997 [32.12201]

∅:D[33.96655] → [2.38972:39751]

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

[33.96655]

[16.30731]

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

Replacement in Cargo.lock at line 2003 [32.12201]

∅:D[16.30886] → [2.39752:39905]

∅:D[2.39905] → [4.57360:57512]

∅:D[6.28904] → [4.57360:57512]

∅:D[7.12288] → [4.57360:57512]

∅:D[10.30328] → [4.57360:57512]

∅:D[18.22599] → [4.57360:57512]

∅:D[31.18848] → [4.57360:57512]

∅:D[4.57360] → [4.57360:57512]

∅:D[4.57512] → [2.39906:40066]

∅:D[2.40066] → [4.57672:57979]

∅:D[6.29065] → [4.57672:57979]

∅:D[10.30489] → [4.57672:57979]

∅:D[18.22760] → [4.57672:57979]

∅:D[31.19009] → [4.57672:57979]

∅:D[4.57672] → [4.57672:57979]

∅:D[4.57979] → [2.40067:40226]

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

[16.30886]

[16.31201]

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

Replacement in Cargo.lock at line 2008 [32.12201]

∅:D[16.31353] → [4.57980:58285]

∅:D[4.58285] → [2.40227:40374]

∅:D[2.40374] → [4.58286:58606]

∅:D[6.29214] → [4.58286:58606]

∅:D[7.12596] → [4.58286:58606]

∅:D[16.31654] → [4.58286:58606]

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

[16.31353]

[33.99130]

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

Replacement in Cargo.lock at line 2014 [32.12201]

∅:D[33.99281] → [4.58607:58758]

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

[33.99281]

[33.99432]

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

Replacement in Cargo.lock at line 2018 [32.12201]

∅:D[33.99889] → [4.58759:58923]

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

[33.99889]

[33.100053]

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

Insertion in Cargo.lock at line 2022 [32.12201]

[33.100517]

[16.31807]

"checksum unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"

Replacement in Cargo.lock at line 2024 [32.12201]

∅:D[16.31953] → [4.58924:59072]

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

[16.31953]

[16.31954]

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

Insertion in Cargo.lock at line 2028 [32.12201]

[33.101417]

[33.101720]

"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 2033 [32.12201]

∅:D[33.102169] → [2.40375:40524]

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

[33.102169]

[33.102318]

"checksum winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "92c1eb33641e276cfa214a0522acad57be5c56b10cb348b3c5117db75f3ac4b0"

Replacement in Cargo.lock at line 2036 [32.12201]

∅:D[33.102642] → [4.59073:59227]

"checksum winapi-util 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7168bab6e1daee33b4557efd0e95d5ca70a03706d39fa5f3fe7a236f584b03c9"

[33.102642]

[33.102796]

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

Replacement in Cargo.lock at line 2043 [32.12201]

∅:D[16.32568] → [4.59228:59384]

∅:D[4.59384] → [2.40525:40681]

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

[16.32568]

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