Switch to tokio 0.2 and async

[?]

Sep 23, 2020, 7:41 PM

NXDEBFWRTMIXUI4G4QV67Z3C2AH7YL777F3V42XMEP3Q6LC63SOAC

Dependencies

[2] KORYGY74 Set presence to account and MUC
[3] SH3LIQ4S Starting commands support
[4] VS6AHRWI Move XMPP to separate dir
[5] SU4DNVCB Start to processing roster data
[6] X6L47BHQ Use different structure for established xmpp connection
[7] MAC6WCSX Fix pipelines
[8] PVCRPP3B Some servers don't send to in initial presence
[9] YTN366WA Support disco#items
[10] ZI4GJ72V Add message to xmpp command
[11] WBU7UOQW Read chatroom from config
[12] 5A5UVGNM Move receiver closing logic out of xmpp processing
[13] RRLRZTMR Use element processor for iq
[14] YEMBT7TB Add support for XEP-0092: Software Version
[15] S754Y5DF Refactor IQ processing Always answer to set and get requests. Use XML encoding for stanzas.
[16] PLWPCM47 Add id to initital presence
[17] HDLI2X4H Ignore delayed XEP-0203 messages
[18] PHPCAQ6Z Use env logger. Implement command loop
[19] TPVUBB3F Answer to ping requests
[20] QWE26TMV update deps
[21] LL3D5CXK Staring using element processor
[22] UAT5MV5O Directly use id for initial roster request
[23] ALP2YJIU Rename XmppState to XmppProcessState
[24] YGC7ZD7N Use logger
[25] AEH7WP42 Make element processors static
[26] U3UZTFCH Re-try to subscribe if not subscribed
[27] XGP44R5H Rework stopping xmpp connection
[28] JY4F7VBC Use element processor for incoming iq set
[29] 3GEU7TC7 Welcome to 2018!
[30] PFC7OJQF Query roster
[31] L3D22A5J Prepare to check incoming presence
[32] ACXUIS63 Update dependecies
[33] TDOR5XQU Accept destination
[34] UMTLHH77 Process commands in the separate function
[35] BTOZT4JP Use failure
[36] JD62RVOJ Update dependencies
[37] BYJPYYSM Process iq ping response
[38] 2THKW66M Ignore .orig files
[39] AYQZ2UIA Update deps
[40] QDHDTOLM Starting support for commands XEP-0050: Ad-Hoc Commands (there no support in xmpp_parsers still)
[41] ZFBPXPAD Cleanup timeouted iq requests with ping Output elapsed time. Refactor iq handling.
[42] QYY3KRGL Use failure instead Box<dyn Error>
[43] DCGEFPRC Better README
[44] UIXIQHDY Wait for commands via new processing code
[45] 5Y6YJ6UH Add shutdown function to make actions before offline
[46] 4LRBIGVT Show info about xmpp errors
[47] 5WHNHD42 Update dependencies
[48] PJV5HPIF Starting to imlements timeouts for iqs
[49] 4IPZTMFI Update dependencies
[50] 6UKCVM6E Use new iq processng for initial roster
[51] CBWCXUZZ Prepare adding new items to roster
[52] 3DSOPLCG Add rustdoc
[53] FV6BJ5K6 Send self-presence and store account info in Rc so it willbe used in some future in parallel
[54] FVVPKFTL Initial commit
[55] HKSQO7JZ Enable hyper http server and configuration
[56] OFLAP2G2 Fix possible utf8 errors
[57] 5IKA4GO7 Rename xmpp client field from "inner" to "client"
[58] 5OBTKGDL Update deps
[59] RQZCVDFD Implement applying timeout for expired iq await
[60] GXQCDLYQ Use element processor for incoming iq get
[61] 6E5IC33Z Try to test 2018 edition
[62] MOXHYSQ3 Use more common error type\n\nMove to failure::Error after https://github.com/rust-lang-nursery/failure/pull/283 landed.
[63] ZT3YEIVX Consume connection on processing command
[64] OB3HA2MD Use Client::new_with_jid to parse jid only once
[65] NDDQQP2P Update deps
[66] QTCUURXN Add additional requirement for command stream
[67] LQXBWNFT Remove unneeded requirement
[68] HU3NZX5Z Process self-presence via new processing code
[69] DYRPAV6T Update dependencies
[70] IK3YDPTY Update deps
[71] CP4MZO6V Leftover commands are processed via stoppable receiver
[72] OANBCLN5 Move xmpp client into XmppState
[73] SSOKGGCE Update dependencies
[74] 37OMJ4CK Send MUC message
[75] WDCZNZOP Fix rustdoc
[76] V5HDBSZM Use jid for receiver address
[77] OGMBXBKP Move online to XmppConnection
[78] W6GSBP3Z Add id for presence stanzas
[79] BWDUANCV Second part of processing result is only about stop_future
[80] FWJDW3G5 Allow process xmpp incoming stanzas with futures
[81] EOHEZXX3 Move request processing to structure
[82] AGIW6YR3 Use shared future for signal everywhere
[83] GVZ4JAR5 Process self-presence with incoming stanza processor
[84] J7VX56FW ToDo
[85] RGOSS73U Convert self-presence to xmpp_parser's type
[86] CCLGGFKR Move out XmppConnection into own file
[87] SA2IOFGY Add items to roster
[88] FCPF2FV6 Break connection on iq error
[89] Z3NQEYVI Rename IqSetHandler to IqResuestHandler as it should provide both get and set handling
[90] AA2ZWGRL Enter to MUC
[91] LNUU5R56 Support disco#info from XEP-0030 Service Discovery
[92] L77O4T7M Formatting and fixes
[93] DCMDASHV Mention XEP-0050 and XEP-0203 support

Change contents

replacement in src/xmpp/xmpp_connection.rs at line 0

[3.21]→[2.0:153](∅→∅)

use tokio_xmpp::{Client, Event, Packet};

use tokio::prelude::future::{self, Either};
use tokio::prelude::stream;
use tokio::prelude::{Future, Stream};

[3.21]

[2.153]

use futures_util::future::Either;
edit in src/xmpp/xmpp_connection.rs at line 3

[2.232]

[2.232]

use tokio_xmpp::{AsyncClient, Event, Packet};

use log::{error, info, warn};
replacement in src/xmpp/xmpp_connection.rs at line 21

[2.491]→[2.491:620](∅→∅)

Chatroom {
muc_id: String,
message: String,
},
// Send ping request to the server to test connection

[2.491]

[2.620]

Chatroom { muc_id: String, message: String },
/// Send ping request to the server to test connection
replacement in src/xmpp/xmpp_connection.rs at line 62

[2.1576]→[2.1576:1604](∅→∅)

jid: xmpp_parsers::Jid,

[2.1576]

[2.1604]

jid: xmpp_parsers::BareJid,
edit in src/xmpp/xmpp_connection.rs at line 92

[2.2605]→[2.2605:2650](∅→∅)

conn.process_jid(&self.jid);
replacement in src/xmpp/xmpp_connection.rs at line 118

[2.3169]→[2.3169:3192](∅→∅)

true // ignore

[2.3169]

[2.3192]

info!("ping successed");
true
edit in src/xmpp/xmpp_connection.rs at line 180

[2.4850]

[2.4850]

}
}

/// data for awaiting iq answer
struct IqWait {
/// time of sending iq
sent: Instant,
/// timeout
timeout: Duration,
/// handler for iq processing
handler: Box<dyn IqHandler>,
}

impl IqWait {
pub fn new<T: IqHandler + 'static>(timeout_secs: u64, handler: T) -> IqWait {
IqWait {
sent: Instant::now(),
timeout: Duration::from_secs(timeout_secs),
handler: Box::new(handler),
}
replacement in src/xmpp/xmpp_connection.rs at line 207

[2.4943]→[2.4943:4970](∅→∅)

xmpp_parsers::Jid,

[2.4943]

[2.4970]

xmpp_parsers::BareJid,
replacement in src/xmpp/xmpp_connection.rs at line 214

[2.5119]→[2.5119:5178](∅→∅)

/// ToDo: remove it as it used only for initialization

[2.5119]

[2.5178]

/// ToDo: remove it as it is used only for initialization
edit in src/xmpp/xmpp_connection.rs at line 216

[2.5201]

[2.5201]

/// if self-presence accepted
/// ToDo: remove it as it is used only for initialization
self_presence: bool,
replacement in src/xmpp/xmpp_connection.rs at line 228

[2.5525]→[2.5525:5590](∅→∅)

pending_ids: HashMap<String, (Instant, Box<dyn IqHandler>)>,

[2.5525]

[2.5590]

pending_ids: HashMap<String, IqWait>,
replacement in src/xmpp/xmpp_connection.rs at line 232

[2.5612]→[2.5612:5632](∅→∅)

client: Client,

[2.5612]

[2.5632]

client: AsyncClient,
replacement in src/xmpp/xmpp_connection.rs at line 241

[2.5751]→[2.5751:5870](∅→∅)

struct XmppElementProcessor {
incoming: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element>,

[2.5751]

[2.5870]

trait IqRequestHandler {
fn process(
self: Box<Self>,
conn: &mut XmppConnection,
id: String,
from: Option<xmpp_parsers::Jid>,
) -> xmpp_parsers::iq::Iq;
}

struct IqRequestUnknown {
element: xmpp_parsers::Element,
type_: &'static str,
}

impl IqRequestHandler for IqRequestUnknown {
fn process(
self: Box<Self>,
conn: &mut XmppConnection,
id: String,
from: Option<xmpp_parsers::Jid>,
) -> xmpp_parsers::iq::Iq {
warn!(
"Unsupported IQ {} request from {:?}: {}",
self.type_,
from,
String::from(&self.element)
);
stanzas::make_iq_unsupported_error(id, conn.account.jid.clone(), from)
}
}

struct IqSetRoster {}

impl IqRequestHandler for IqSetRoster {
fn process(
self: Box<Self>,
conn: &mut XmppConnection,
id: String,
from: Option<xmpp_parsers::Jid>,
) -> xmpp_parsers::iq::Iq {
info!("Got roster push {} from {:?}", id, from);
stanzas::make_roster_push_answer(id, conn.account.jid.clone(), from)
}
}

struct IqGetPing {}

impl IqRequestHandler for IqGetPing {
fn process(
self: Box<Self>,
conn: &mut XmppConnection,
id: String,
from: Option<xmpp_parsers::Jid>,
) -> xmpp_parsers::iq::Iq {
info!("Got ping {} from {:?}", id, from);
stanzas::make_pong(id, conn.account.jid.clone(), from)
}
}

struct IqGetVersion {}

impl IqRequestHandler for IqGetVersion {
fn process(
self: Box<Self>,
conn: &mut XmppConnection,
id: String,
from: Option<xmpp_parsers::Jid>,
) -> xmpp_parsers::iq::Iq {
info!("Got version query {} from {:?}", id, from);
stanzas::make_version(id, conn.account.jid.clone(), from)
}
}

struct IqGetDiscoInfo {}

impl IqRequestHandler for IqGetDiscoInfo {
fn process(
self: Box<Self>,
conn: &mut XmppConnection,
id: String,
from: Option<xmpp_parsers::Jid>,
) -> xmpp_parsers::iq::Iq {
info!("Got disco query {} from {:?}", id, from);
stanzas::make_disco_info_result(id, conn.account.jid.clone(), from)
}
}

struct IqGetDiscoItems {}

impl IqRequestHandler for IqGetDiscoItems {
fn process(
self: Box<Self>,
conn: &mut XmppConnection,
id: String,
from: Option<xmpp_parsers::Jid>,
) -> xmpp_parsers::iq::Iq {
info!("Got disco items query {} from {:?}", id, from);
stanzas::make_disco_items_result(id, conn.account.jid.clone(), from)
}
}

struct IqGetDiscoCommands {}

impl IqRequestHandler for IqGetDiscoCommands {
fn process(
self: Box<Self>,
conn: &mut XmppConnection,
id: String,
from: Option<xmpp_parsers::Jid>,
) -> xmpp_parsers::iq::Iq {
info!("Got disco commands query {} from {:?}", id, from);
stanzas::make_disco_items_commands(id, conn.account.jid.clone(), from)
}
replacement in src/xmpp/xmpp_connection.rs at line 356

[2.5873]→[2.5873:5940](∅→∅)

impl XmppElementProcessor {
fn new() -> XmppElementProcessor {

[2.5873]

[2.5940]

lazy_static::lazy_static! {
static ref INCOMING: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element> = {
replacement in src/xmpp/xmpp_connection.rs at line 363

[2.6166]→[2.6166:6215](∅→∅)

XmppElementProcessor { incoming }
}

[2.6166]

[2.6215]

incoming.register(&XmppConnection::incoming_presence_processing);
incoming.register(&XmppConnection::incoming_message_processing);
incoming
};
static ref INCOMING_IQ_SET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
let mut iq_set =
element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
Box::new(IqRequestUnknown {
element,
type_: "set",
}) as Box<dyn IqRequestHandler>
});
iq_set.register(&XmppConnection::incoming_iq_processing_set_roster);
iq_set
};
static ref INCOMING_IQ_GET: element_processor::Processor<XmppConnection, Box<dyn IqRequestHandler>, xmpp_parsers::Element> = {
let mut iq_get =
element_processor::Processor::new(&|_conn: &mut XmppConnection, element| {
Box::new(IqRequestUnknown {
element,
type_: "get",
}) as Box<dyn IqRequestHandler>
});
iq_get.register(&XmppConnection::incoming_iq_processing_get_ping);
iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_info);
iq_get.register(&XmppConnection::incoming_iq_processing_get_disco_items);
iq_get.register(&XmppConnection::incoming_iq_processing_get_version);
iq_get
};
replacement in src/xmpp/xmpp_connection.rs at line 429

[2.7147]→[2.7147:7276](∅→∅)

pub fn connect<F>(
self,
stop_future: F,
) -> impl Future<Item = XmppConnection, Error = failure::Error>

[2.7147]

[2.7276]

pub async fn connect<F>(self, stop_future: F) -> Result<XmppConnection, failure::Error>
replacement in src/xmpp/xmpp_connection.rs at line 431

[2.7286]→[2.7286:7401](∅→∅)

F: future::Future + Clone + 'static,
<F as hyper::rt::Future>::Error: Into<failure::Error> + Send,

[2.7286]

[2.7401]

F: std::future::Future<Output = ()> + Clone + 'static,
replacement in src/xmpp/xmpp_connection.rs at line 433

[2.7407]→[2.7407:7444](∅→∅)

info!("xmpp connection...");

[2.7407]

[2.7444]

info!("xmpp check connection...");
replacement in src/xmpp/xmpp_connection.rs at line 437

[2.7541]→[2.7541:7665](∅→∅)

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

[2.7541]

[2.7665]

Ok(XmppConnection { account, state })
replacement in src/xmpp/xmpp_connection.rs at line 439

[2.7682]→[2.7682:8108](∅→∅)

Box::new(
stop_future
.clone()
.select2(
future::loop_fn(account, move |account| {
info!("xmpp initialization...");
let client =
Client::new_with_jid(account.jid.clone(), &account.password);
info!("xmpp initialized");

[2.7682]

[2.8108]

loop {
let pin_stop_future = stop_future.clone();
tokio::pin!(pin_stop_future);
let connect = futures_util::future::select(
pin_stop_future,
Box::pin(async {
info!("xmpp initialization...");
let mut client = AsyncClient::new_with_jid(
account.jid.clone(),
account.password.clone(),
);
client.set_reconnect(false);

let stop_future = stop_future.clone();

let (connected, stopped) = XmppConnection {
state: XmppState {
client,
data: std::default::Default::default(),
},
account: account.clone(),
}
.processing(XmppConnection::online, Box::pin(stop_future), true)
.await;

let (connected, stopped) = match (connected, stopped) {
(Ok(connection), Either::Left(stop_future)) => {
connection.initial_roster(stop_future).await
}
(connected, stopped) => (connected, stopped),
};
replacement in src/xmpp/xmpp_connection.rs at line 471

[2.8109]→[2.8109:8313](∅→∅)

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

[2.8109]

[2.8313]

let (connected, stopped) = match (connected, stopped) {
(Ok(connection), Either::Left(stop_future)) => {
connection.self_presence(stop_future).await
}
(connected, stopped) => (connected, stopped),
};
replacement in src/xmpp/xmpp_connection.rs at line 478

[2.8314]→[2.8314:10292](∅→∅)

// 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))
.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)),
}),
)
})
.map_err(|_: ()| ()),
)
.then(|r| match r {
Ok(Either::A((_x, _b))) => future::err(format_err!("Stop XMMP connection")),
Ok(Either::B((x, _a))) => future::ok(x),
Err(Either::A((e, _b))) => future::err(e.into()),
Err(Either::B((_, _a))) => {
future::err(format_err!("Cann't initiate XMPP connection"))

[2.8314]

[2.10292]

match (connected, stopped) {
(Ok(connection), Either::Left(stop_future)) => {
connection.enter_mucs(stop_future).await
}
(connected, stopped) => (connected, stopped),
replacement in src/xmpp/xmpp_connection.rs at line 485

[2.10342]→[2.10342:10356](∅→∅)

)

[2.10342]

[2.10356]

)
.await;
match connect {
Either::Left((_, _)) => {
break Err(failure::format_err!("Stop XMPP connection"))
}
Either::Right(((_, Either::Right(_)), _)) => {
break Err(failure::format_err!("Stop XMPP connection(2)"))
}
Either::Right(((result, Either::Left(_)), _)) => match result {
Ok(connection) => break Ok(connection),
Err(account) => {}
},
}
}
replacement in src/xmpp/xmpp_connection.rs at line 509

[2.10552]→[2.10552:10838](∅→∅)

Event::Stanza(stanza) => {
let processors = XmppElementProcessor::new();
processors.incoming.process(self, stanza.clone())
}
Event::Online => true,
e => {
warn!("Unexpected event {:?}", e);

[2.10552]

[2.10838]

Event::Stanza(stanza) => INCOMING.process(self, stanza.clone()),
Event::Online { .. } => true,
Event::Disconnected(error) => {
error!("Unexpected event {:?}", error);
edit in src/xmpp/xmpp_connection.rs at line 514

[2.10860]

[2.10860]

}
}
}

/// Process roster push
/// see RFC 6212 2.1.6. Roster Push
fn incoming_iq_processing_set_roster(
&mut self,
roster: xmpp_parsers::roster::Roster,
) -> Box<dyn IqRequestHandler> {
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));
edit in src/xmpp/xmpp_connection.rs at line 537

[2.10884]

[2.10884]

Box::new(IqSetRoster {})
replacement in src/xmpp/xmpp_connection.rs at line 547

[2.11111]→[2.11111:11880](∅→∅)

use std::convert::TryInto;
if let Some(roster) =
element.clone().try_into().ok() as Option<xmpp_parsers::roster::Roster>
{
// RFC 6212 2.1.6. Roster Push
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);

[2.11111]

[2.11880]

INCOMING_IQ_SET
.process(self, element)
.process(self, id, from)
}

/// Process ping request
/// see XEP-0199: XMPP Ping
fn incoming_iq_processing_get_ping(
&mut self,
_ping: xmpp_parsers::ping::Ping,
) -> Box<dyn IqRequestHandler> {
Box::new(IqGetPing {})
}

/// Process disco query
/// see XEP-0030: Service Discovery
fn incoming_iq_processing_get_disco_info(
&mut self,
disco: xmpp_parsers::disco::DiscoInfoQuery,
) -> Box<dyn IqRequestHandler> {
if let Some(ref node) = disco.node {
warn!("Unsupported node {}", node);
Box::new(IqRequestUnknown {
element: disco.into(),
type_: "get",
})
} else {
Box::new(IqGetDiscoInfo {})
}
}

/// Process disco items query
/// see XEP-0030: Service Discovery
fn incoming_iq_processing_get_disco_items(
&mut self,
disco: xmpp_parsers::disco::DiscoItemsQuery,
) -> Box<dyn IqRequestHandler> {
match &disco.node {
Some(node) if node == "http://jabber.org/protocol/commands" => {
Box::new(IqGetDiscoCommands {})
replacement in src/xmpp/xmpp_connection.rs at line 588

[2.11894]→[2.11894:11988](∅→∅)

return stanzas::make_roster_push_answer(id, self.state.client.jid.clone(), from);

[2.11894]

[2.11988]

Some(node) => {
warn!("Unsupported node {}", node);
Box::new(IqRequestUnknown {
element: disco.into(),
type_: "get",
})
}
None => Box::new(IqGetDiscoItems {}),
replacement in src/xmpp/xmpp_connection.rs at line 597

[2.11998]→[2.11998:12217](∅→∅)

warn!(
"Unsupported IQ set request from {:?}: {}",
from,
String::from(&element)
);
stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)

[2.11998]

[2.12217]

}

/// Process version query
/// see XEP-0092: Software Version
fn incoming_iq_processing_get_version(
&mut self,
_version: xmpp_parsers::version::VersionQuery,
) -> Box<dyn IqRequestHandler> {
Box::new(IqGetVersion {})
replacement in src/xmpp/xmpp_connection.rs at line 615

[2.12444]→[2.12444:12888](∅→∅)

use std::convert::TryInto;
if let Some(_ping) = element.clone().try_into().ok() as Option<xmpp_parsers::ping::Ping> {
return stanzas::make_pong(&id, self.state.client.jid.clone(), from);
}
warn!(
"Unsupported IQ get request from {:?}: {}",
from,
String::from(&element)
);
stanzas::make_iq_unsupported_error(id, self.state.client.jid.clone(), from)

[2.12444]

[2.12888]

INCOMING_IQ_GET
.process(self, element)
.process(self, id, from)
replacement in src/xmpp/xmpp_connection.rs at line 627

[2.13283]→[2.13283:13431](∅→∅)

if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
return handler.1.error(self, e);

[2.13283]

[2.13431]

if let Some((_, data)) = self.state.data.pending_ids.remove_entry(&iq.id) {
return data.handler.error(self, e);
replacement in src/xmpp/xmpp_connection.rs at line 638

[2.13833]→[2.13833:13992](∅→∅)

if let Some((_, handler)) = self.state.data.pending_ids.remove_entry(&iq.id) {
return handler.1.result(self, opt_element);

[2.13833]

[2.13992]

if let Some((_, data)) = self.state.data.pending_ids.remove_entry(&iq.id) {
let now = Instant::now();
if data.sent + data.timeout > now {
info!(
"Timeout for {} was {:?} expected {:?}",
iq.id,
now - data.sent,
data.timeout
);
return data.handler.result(self, opt_element);
} else {
warn!(
"Timeout for {} was {:?} expected {:?}",
iq.id,
now - data.sent,
data.timeout
);
return data.handler.timeout(self);
}
replacement in src/xmpp/xmpp_connection.rs at line 669

[2.14274]→[2.14274:14587](∅→∅)

/// process event from xmpp stream
/// returns from future when condition met
/// or stop future was resolved.
/// Return item if connection was preserved or error otherwise.
/// Second part is a state of stop_future
pub fn processing<S, F, T, E>(
self,
stop_condition: S,

[2.14274]

[2.14587]

fn incoming_presence_processing(&mut self, presence: xmpp_parsers::presence::Presence) -> bool {
if presence.from.as_ref() == Some(&self.account.jid) {
info!("Self-presence accepted");
self.state.data.self_presence = true;
} else {
warn!("Incoming presence stanza: {:?}", presence);
}
true
}

fn incoming_message_processing(&mut self, message: xmpp_parsers::message::Message) -> bool {
for payload in message.payloads.iter() {
use std::convert::TryInto;
if let Some(_delay) =
payload.clone().try_into().ok() as Option<xmpp_parsers::delay::Delay>
{
return true; // ignore delayed messages
}
}
warn!("Incoming message stanza: {:?}", message);
true
}

/// first data: return Ok(conn) if still connected, Err(account) if disconnected
/// second data: true if stopped
pub async fn processing<S, F, O>(
mut self,
mut stop_condition: S,
replacement in src/xmpp/xmpp_connection.rs at line 698

[2.14611]→[2.14611:14760](∅→∅)

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

[2.14611]

[2.14760]

stop_fatal: bool,
) -> (Result<Self, std::rc::Rc<config::Account>>, Either<F, O>)
edit in src/xmpp/xmpp_connection.rs at line 701

[2.14770]→[2.14770:14820](∅→∅)

F: Future<Item = T, Error = E> + 'static,
replacement in src/xmpp/xmpp_connection.rs at line 702

[2.14886]→[2.14886:14926](∅→∅)

T: 'static,
E: 'static,

[2.14886]

[2.14926]

F: std::future::Future<Output = O> + Unpin,
replacement in src/xmpp/xmpp_connection.rs at line 704

[2.14932]→[2.14932:17020](∅→∅)

future::loop_fn(
(self, stop_future, stop_condition),
|(xmpp, stop_future, mut stop_condition)| {
// ToDo: check timeouts if iqs

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

if let Some(send_element) = data.send_queue.pop_front() {
use tokio::prelude::Sink;

info!("Sending {}", String::from(&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))))

[2.14932]

[2.17020]

let account = self.account.clone();
let mut stop_future = stop_future;
loop {
if let Some(send_element) = self.state.data.send_queue.pop_front() {
info!("Sending {}", String::from(&send_element));
let stop = {
let send_future = self.state.client.send_stanza(send_element);
tokio::pin!(send_future);
match futures_util::future::select(stop_future, send_future).await {
Either::Left((stop, send_future)) => {
if stop_fatal {
warn!("Sending interrupted!");
} else {
match send_future.await {
Ok(_) => {
info!("Sent!");
replacement in src/xmpp/xmpp_connection.rs at line 721

[2.17058]→[2.17058:18037](∅→∅)

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

[2.17058]

[2.18037]

Err(e) => {
error!("Send stanza error: {}", e);
break (Err(self.account), Either::Right(stop));
replacement in src/xmpp/xmpp_connection.rs at line 725

[2.18075]→[2.18075:18823](∅→∅)

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

[2.18075]

[2.18823]

}
}
stop
}
Either::Right((Ok(_), f)) => {
info!("Sent!");
stop_future = f;
continue;
}
Either::Right((Err(e), f)) => {
error!("Send stanza error: {}", e);
break (Err(self.account), Either::Left(f));
}
}
};
break (Ok(self), Either::Right(stop));
} else {
use futures_util::StreamExt;
replacement in src/xmpp/xmpp_connection.rs at line 744

[2.18824]→[2.18824:22012](∅→∅)

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

[2.18824]

[2.22012]

let recv_future = self.state.client.next();
tokio::pin!(recv_future);
match futures_util::future::select(stop_future, recv_future).await {
Either::Left((stop, s)) => break (Ok(self), Either::Right(stop)),
Either::Right((None, f)) => {
break (Err(self.account), Either::Left(f));
}
Either::Right((Some(event), f)) => {
stop_future = f;
if (self.xmpp_processing(&event)) {
match stop_condition(&mut self, event) {
Ok(true) => break (Ok(self), Either::Left(stop_future)),
Ok(false) => {}
Err(_) => break (Err(self.account), Either::Left(stop_future)),
}
} else {
break (Err(self.account), Either::Left(stop_future));
}
}
replacement in src/xmpp/xmpp_connection.rs at line 764

[2.22030]→[2.22030:22055](∅→∅)

},
)

[2.22030]

[2.22055]

}
}
replacement in src/xmpp/xmpp_connection.rs at line 772

[2.22288]→[2.22288:22319](∅→∅)

Event::Online => {

[2.22288]

[2.22319]

Event::Online { .. } => {
replacement in src/xmpp/xmpp_connection.rs at line 780

[2.22535]→[2.22535:22607](∅→∅)

_ => {
error!("Disconnected while online");

[2.22535]

[2.22607]

Event::Disconnected(e) => {
error!("Disconnected while waiting online: {:?}", e);
replacement in src/xmpp/xmpp_connection.rs at line 787

[2.22662]→[2.22662:22705](∅→∅)

fn initial_roster<F, E>(
self,

[2.22662]

[2.22705]

async fn initial_roster<F>(
mut self,
replacement in src/xmpp/xmpp_connection.rs at line 790

[2.22729]→[2.22729:22801](∅→∅)

) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>

[2.22729]

[2.22801]

) -> (Result<Self, std::rc::Rc<config::Account>>, Either<F, ()>)
replacement in src/xmpp/xmpp_connection.rs at line 792

[2.22811]→[2.22811:22871](∅→∅)

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

[2.22811]

[2.22871]

F: std::future::Future<Output = ()> + Unpin,
replacement in src/xmpp/xmpp_connection.rs at line 794

[2.22877]→[2.22877:23130](∅→∅)

let XmppConnection {
account,
state: XmppState { client, mut data },
} = self;
use tokio::prelude::Sink;

data.counter += 1;
let id_init_roster = format!("id_init_roster{}", data.counter);

[2.22877]

[2.23130]

self.state.data.counter += 1;
let id_init_roster = format!("id_init_roster{}", self.state.data.counter);
edit in src/xmpp/xmpp_connection.rs at line 797

[2.23198]→[2.23198:23238](∅→∅)

let account2 = account.clone();
replacement in src/xmpp/xmpp_connection.rs at line 798

[2.23304]→[2.23304:23337](∅→∅)

data.pending_ids.insert(

[2.23304]

[2.23337]

self.state.data.pending_ids.insert(
replacement in src/xmpp/xmpp_connection.rs at line 800

[2.23373]→[2.23373:23510](∅→∅)

(
Instant::now() + Duration::from_secs(60),
Box::new(InitRosterIqHandler {}),
),

[2.23373]

[2.23510]

IqWait::new(60, InitRosterIqHandler {}),
replacement in src/xmpp/xmpp_connection.rs at line 802

[2.23521]→[2.23521:23869](∅→∅)

client
.send(Packet::Stanza(get_roster))
.map_err(move |e| {
error!("Error on querying roster: {}", e);
account2
})
.and_then(move |client| {
XmppConnection {
state: XmppState { client, data },
account,

[2.23521]

[2.23869]

let stop_future = {
let send_future = self.state.client.send_stanza(get_roster);
tokio::pin!(send_future);
match futures_util::future::select(stop_future, send_future).await {
Either::Left(((), _)) => None,
Either::Right((Ok(_), stop_future)) => Some(stop_future),
Either::Right((Err(e), f)) => {
error!("Send initial roster stanza error: {}", e);
return (Err(self.account), Either::Left(f));
replacement in src/xmpp/xmpp_connection.rs at line 812

[2.23887]→[2.23887:24290](∅→∅)

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

[2.23887]

[2.24290]

}
};
if let Some(stop_future) = stop_future {
self.processing(
move |conn, _| Ok(conn.state.data.roster_init),
stop_future,
true,
)
.await
} else {
(Ok(self), Either::Right(()))
}
replacement in src/xmpp/xmpp_connection.rs at line 826

[2.24297]→[2.24297:24339](∅→∅)

fn self_presence<F, E>(
self,

[2.24297]

[2.24339]

async fn self_presence<F>(
mut self,
replacement in src/xmpp/xmpp_connection.rs at line 829

[2.24363]→[2.24363:24435](∅→∅)

) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>

[2.24363]

[2.24435]

) -> (Result<Self, std::rc::Rc<config::Account>>, Either<F, ()>)
replacement in src/xmpp/xmpp_connection.rs at line 831

[2.24445]→[2.24445:24528](∅→∅)

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

[2.24445]

[2.24528]

F: std::future::Future<Output = ()> + Unpin,
replacement in src/xmpp/xmpp_connection.rs at line 833

[2.24534]→[2.24534:24687](∅→∅)

let XmppConnection {
account,
state: XmppState { client, mut data },
} = self;
use tokio::prelude::Sink;

[2.24534]

[2.24687]

self.state.data.counter += 1;
replacement in src/xmpp/xmpp_connection.rs at line 835

[2.24688]→[2.24688:24945](∅→∅)

data.counter += 1;
let id_presence = format!("id_init_presence{}", data.counter);
let presence = stanzas::make_presence(id_presence, xmpp_parsers::presence::Show::None, "Online!".to_string());
let account2 = account.clone();

[2.24688]

[2.24945]

let id_presence = format!("id_init_presence{}", self.state.data.counter);
let presence = stanzas::make_presence(id_presence, None, "Online!".to_string());
replacement in src/xmpp/xmpp_connection.rs at line 838

[2.25011]→[2.25011:25355](∅→∅)

client
.send(Packet::Stanza(presence))
.map_err(|e| {
error!("Error on send self-presence: {}", e);
account2
})
.and_then(move |client| {
XmppConnection {
state: XmppState { client, data },
account,

[2.25011]

[2.25355]

let stop_future = {
let send_future = self.state.client.send_stanza(presence);
tokio::pin!(send_future);
match futures_util::future::select(stop_future, send_future).await {
Either::Left(((), send_future)) => None,
Either::Right((Ok(_), stop_future)) => Some(stop_future),
Either::Right((Err(e), f)) => {
error!("Send self-presence stanza error: {}", e);
return (Err(self.account), Either::Left(f));
edit in src/xmpp/xmpp_connection.rs at line 848

[2.25373]→[2.25373:29388](∅→∅)

.processing(
move |conn, event| {
if let Event::Stanza(s) = event {
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)
}
}
} else {
error!("Wrong event while waiting self-presence");
Err(())
}
},
stop_future,
)
.map_err(|(account, _)| account)
.and_then(|(conn, r)| match r {
Ok(Either::A(_)) => future::ok(conn),
Ok(Either::B(_)) => future::err(conn.account),
Err(_e) => future::err(conn.account),
})
})
}

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()));
}
let sub_from = match rdata.0 {
xmpp_parsers::roster::Subscription::From => true,
xmpp_parsers::roster::Subscription::Both => true,
_ => false,
};
if !sub_from {
info!("Not subscription from {}", xmpp_to);
self.state
.data
.send_queue
.push_back(stanzas::make_allow_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());
info!("Adding jid {} to roster id {}", xmpp_to, id_add_roster);
self.state.data.pending_ids.insert(
id_add_roster,
(
Instant::now() + Duration::from_secs(60),
Box::new(AddRosterIqHandler {
jid: xmpp_to.clone(),
}),
),
);
self.state.data.send_queue.push_back(add_roster);
}
edit in src/xmpp/xmpp_connection.rs at line 849

[2.29402]

[2.29402]

};
if let Some(stop_future) = stop_future {
self.processing(
move |conn, _| Ok(conn.state.data.self_presence),
stop_future,
true,
)
.await
} else {
(Ok(self), Either::Right(()))
replacement in src/xmpp/xmpp_connection.rs at line 862

[2.29419]→[2.29419:29507](∅→∅)

pub fn process_command(&mut self, cmd: XmppCommand) {
info!("Got command");

[2.29419]

[2.29507]

pub fn process_command(mut self, cmd: XmppCommand) -> MaybeXmppConnection {
edit in src/xmpp/xmpp_connection.rs at line 864

[2.29527]→[2.29527:31069](∅→∅)

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::ChatroomPresence { muc_id, show, message } => {
if let Some(muc) = self.state.data.mucs.get(&muc_id) {
self.state.data.counter += 1;
let id_presence = format!("id_presence{}", self.state.data.counter);
self.state
.data
.send_queue
.push_back(stanzas::make_muc_presence(
&id_presence,
self.account.jid.clone(),
muc.clone(),
show,
Some(message),
));
} else {
error!("Not found MUC {}", muc_id);
}
}
replacement in src/xmpp/xmpp_connection.rs at line 867

[2.31257]→[2.31257:31426](∅→∅)

self.state
.data
.send_queue
.push_back(stanzas::make_presence(id_presence, show, message));

[2.31257]

[2.31426]

self.state.data.send_queue.push_back(stanzas::make_presence(
id_presence,
Some(show),
message,
));
replacement in src/xmpp/xmpp_connection.rs at line 876

[2.31598]→[2.31598:31990](∅→∅)

let ping = stanzas::make_ping(&id_ping, self.state.client.jid.clone());
self.state.data.send_queue.push_back(ping);
self.state.data.pending_ids.insert(
id_ping,
(
Instant::now() + Duration::from_secs(30),
Box::new(PingIqHandler {}),
),

[2.31598]

[2.31990]

let ping = stanzas::make_ping(
&id_ping,
self.state
.client
.bound_jid()
.map_or_else(|| self.account.jid.clone(), |j| j.clone()),
edit in src/xmpp/xmpp_connection.rs at line 883

[2.32009]

[2.32009]

self.state.data.send_queue.push_back(ping);
self.state
.data
.pending_ids
.insert(id_ping, IqWait::new(30, PingIqHandler {}));
replacement in src/xmpp/xmpp_connection.rs at line 896

[2.32274]→[2.32274:32374](∅→∅)

.filter_map(|(id, (timeout, _))| {
if now >= *timeout {

[2.32274]

[2.32374]

.filter_map(|(id, data)| {
if now >= data.sent + data.timeout {
warn!(
"Timeout for {} was {:?} expected {:?}",
id,
now - data.sent,
data.timeout
);
replacement in src/xmpp/xmpp_connection.rs at line 912

[2.32664]→[2.32664:32817](∅→∅)

if let Some((_, handler)) = self.state.data.pending_ids.remove(&id) {
correct &= handler.timeout(&mut self);

[2.32664]

[2.32817]

if let Some(data) = self.state.data.pending_ids.remove(&id) {
correct &= data.handler.timeout(&mut self);
edit in src/xmpp/xmpp_connection.rs at line 917

[2.32872]

[2.32872]

_ => todo!(),
edit in src/xmpp/xmpp_connection.rs at line 919

[2.32882]

[2.32882]

self.into()
replacement in src/xmpp/xmpp_connection.rs at line 922

[2.32889]→[2.32889:34079](∅→∅)

pub 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... {}",
String::from(&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>>

[2.32889]

[2.34079]

async fn enter_mucs<F>(
mut self,
mut stop_future: F,
) -> (Result<Self, std::rc::Rc<config::Account>>, Either<F, ()>)
replacement in src/xmpp/xmpp_connection.rs at line 927

[2.34089]→[2.34089:34172](∅→∅)

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

[2.34089]

[2.34172]

F: std::future::Future<Output = ()> + Unpin,
replacement in src/xmpp/xmpp_connection.rs at line 929

[2.34178]→[2.34178:35575](∅→∅)

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(),
xmpp_parsers::presence::Show::None,
None,
);

info!("Sending muc presence... {}", String::from(&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,
})

[2.34178]

[2.35575]

for chatroom in &self.account.chatrooms {
self.state.data.counter += 1;
let id_muc_presence = format!("id_muc_presence{}", self.state.data.counter);
let muc_presence = stanzas::make_muc_presence(
&id_muc_presence,
self.account.jid.clone(),
chatroom.1.clone(),
None,
None,
);
info!("Sending muc presence... {}", String::from(&muc_presence));
let opt_stop_future = {
let send_future = self.state.client.send_stanza(muc_presence);
tokio::pin!(send_future);
match futures_util::future::select(stop_future, send_future).await {
Either::Left(((), _)) => None,
Either::Right((Ok(_), stop_future)) => Some(stop_future),
Either::Right((Err(e), f)) => {
error!("Send self-presence stanza error: {}", e);
return (Err(self.account), Either::Left(f));
}
}
};
if let Some(f) = opt_stop_future {
stop_future = f;
} else {
return (Ok(self), Either::Right(()));
}
}
(Ok(self), Either::Left(stop_future))
edit in src/xmpp/stanzas.rs at line 1

[3.57]

[3.35309]

use xmpp_parsers::disco::{DiscoInfoResult, DiscoItemsResult, Feature, Identity};
edit in src/xmpp/stanzas.rs at line 8

[2.35660]

[3.141]

use xmpp_parsers::version::VersionResult;
use xmpp_parsers::{BareJid, Jid};
replacement in src/xmpp/stanzas.rs at line 11

[3.142]→[2.35661:35741](∅→∅)

pub fn make_presence(id: String, show: PresenceShow, text: String) -> Element {

[3.142]

[3.196]

pub fn make_presence(id: String, show: Option<PresenceShow>, text: String) -> Element {
replacement in src/xmpp/stanzas.rs at line 15

[2.35796]→[3.294:325](∅→∅),[3.294]→[3.294:325](∅→∅),[3.325]→[2.35797:35840](∅→∅)

presence
.statuses
.insert(String::from("en"), text);

[2.35796]

[3.35542]

presence.statuses.insert(String::from("en"), text);
replacement in src/xmpp/stanzas.rs at line 30

[3.35740]→[3.35740:35810](∅→∅),[3.35740]→[3.35740:35810](∅→∅),[3.35740]→[3.35740:35810](∅→∅),[3.35740]→[3.35740:35810](∅→∅),[3.35740]→[3.35740:35810](∅→∅)

pub fn make_add_roster(id: &str, jid: xmpp_parsers::Jid) -> Element {

[3.35740]

[3.34351]

pub fn make_add_roster(id: &str, jid: xmpp_parsers::BareJid) -> Element {
replacement in src/xmpp/stanzas.rs at line 58

[2.36093]→[2.36093:36156](∅→∅)

pub fn make_ask_subscribe(jid: xmpp_parsers::Jid) -> Element {

[2.36093]

[3.36481]

pub fn make_ask_subscribe(id: String, jid: xmpp_parsers::Jid) -> Element {
edit in src/xmpp/stanzas.rs at line 60

[3.36544]

[3.34957]

presence.id = Some(id);
replacement in src/xmpp/stanzas.rs at line 65

[3.35009]→[2.36157:36222](∅→∅)

pub fn make_allow_subscribe(jid: xmpp_parsers::Jid) -> Element {

[3.35009]

[3.35074]

pub fn make_allow_subscribe(id: String, jid: xmpp_parsers::Jid) -> Element {
edit in src/xmpp/stanzas.rs at line 67

[3.35138]

[3.39862]

presence.id = Some(id);
replacement in src/xmpp/stanzas.rs at line 83

[2.36319]→[2.36319:36343](∅→∅)

show: PresenceShow,

[2.36319]

[2.36343]

show: Option<PresenceShow>,
replacement in src/xmpp/stanzas.rs at line 85

[2.36369]→[2.36369:36388](∅→∅)

) -> Element {

[2.36369]

[3.37111]

) -> Element {
replacement in src/xmpp/stanzas.rs at line 92

[2.36446]→[2.36446:36532](∅→∅)

presence
.statuses
.insert(String::from("en"), text);

[2.36446]

[2.36532]

presence.statuses.insert(String::from("en"), text);
replacement in src/xmpp/stanzas.rs at line 99

[3.37402]→[3.37402:37464](∅→∅)

let mut message = Message::new(Some(to.into_bare_jid()));

[3.37402]

[3.37464]

let mut message = Message::new(Some(Jid::Bare(to.into())));
replacement in src/xmpp/stanzas.rs at line 113

[3.40352]→[3.35139:35182](∅→∅),[3.39498]→[3.40395:40475](∅→∅),[3.35182]→[3.40395:40475](∅→∅),[3.40395]→[3.40395:40475](∅→∅)

let mut ping = Iq::from_get(id, Ping);
ping.to = Some(from.clone().into_domain_jid());
ping.from = Some(from);

[3.40352]

[3.40475]

let ping = Iq::from_get(id, Ping)
.with_to(Jid::Bare(BareJid::domain(from.clone().domain())))
.with_from(from);
replacement in src/xmpp/stanzas.rs at line 119

[3.35186]→[2.36539:36630](∅→∅)

pub fn make_pong(id: &str, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Iq {

[3.35186]

[3.35277]

pub fn make_pong(id: String, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Iq {
edit in src/xmpp/stanzas.rs at line 126

[2.36643]

[2.36643]

pub fn make_version(id: String, from: xmpp_parsers::Jid, to: Option<xmpp_parsers::Jid>) -> Iq {
let mut version = Iq::from_result(
id,
Some(VersionResult {
name: "SendXmppDRust".to_string(),
version: "0.1.0".to_string(),
os: None,
}),
);
version.from = Some(from);
version.to = to;
version
}
edit in src/xmpp/stanzas.rs at line 159

[3.41576]

pub fn make_disco_info_result(
id: String,
from: xmpp_parsers::Jid,
to: Option<xmpp_parsers::Jid>,
) -> Iq {
let mut result = Iq::from_result(
id,
Some(DiscoInfoResult {
node: None,
identities: vec![Identity {
category: "client".to_string(),
type_: "bot".to_string(),
name: None,
lang: None,
}],
features: vec![
Feature {
var: "http://jabber.org/protocol/disco#info".to_string(),
},
Feature {
var: "urn:xmpp:ping".to_string(),
},
Feature {
var: "http://jabber.org/protocol/commands".to_string(),
},
],
extensions: vec![],
}),
);
result.from = Some(from);
result.to = to;
result
}

pub fn make_disco_items_result(
id: String,
from: xmpp_parsers::Jid,
to: Option<xmpp_parsers::Jid>,
) -> Iq {
let mut result = Iq::from_result(
id,
Some(DiscoItemsResult {
node: None,
items: vec![],
}),
);
result.from = Some(from);
result.to = to;
result
}

pub fn make_disco_items_commands(
id: String,
from: xmpp_parsers::Jid,
to: Option<xmpp_parsers::Jid>,
) -> Iq {
let mut result = Iq::from_result(
id,
Some(DiscoItemsResult {
node: Some("http://jabber.org/protocol/commands".to_string()),
items: vec![],
}),
);
result.from = Some(from);
result.to = to;
result
}
replacement in src/xmpp/mod.rs at line 0

[3.17]→[3.35892:35944](∅→∅),[3.38791]→[3.62:90](∅→∅),[3.29761]→[3.62:90](∅→∅),[3.34213]→[3.62:90](∅→∅),[3.29518]→[3.62:90](∅→∅),[3.33362]→[3.62:90](∅→∅),[3.39333]→[3.62:90](∅→∅),[3.39054]→[3.62:90](∅→∅),[3.29446]→[3.62:90](∅→∅),[3.32821]→[3.62:90](∅→∅),[3.35944]→[3.62:90](∅→∅),[3.42773]→[3.62:90](∅→∅),[3.62]→[3.62:90](∅→∅)

use tokio::prelude::future::{self, Either, Future};
use tokio::prelude::stream;

[3.17]

[3.197]

use futures_util::future::Either;

use log::{error, info, warn};
replacement in src/xmpp/mod.rs at line 31

[3.4137]→[3.212:239](∅→∅)

pub fn xmpp_process<F, S>(

[3.4137]

[3.4161]

pub async fn xmpp_process<F, S>(
replacement in src/xmpp/mod.rs at line 33

[3.4176]→[3.240:257](∅→∅)

cmd_recv: S,

[3.4176]

[3.4213]

mut cmd_recv: S,
replacement in src/xmpp/mod.rs at line 35

[3.4243]→[3.39158:39218](∅→∅)

) -> impl future::Future<Item = (), Error = failure::Error>

[3.4243]

[3.4305]

) -> Result<(), failure::Error>
replacement in src/xmpp/mod.rs at line 37

[3.4311]→[3.39219:39399](∅→∅)

F: future::Future + Clone + 'static,
<F as hyper::rt::Future>::Error: std::fmt::Display + Into<failure::Error> + Send,
S: stream::Stream<Item = XmppCommand> + 'static,

[3.4311]

[3.4355]

F: std::future::Future<Output = ()> + Clone + 'static,
S: tokio::stream::Stream<Item = XmppCommand> + Unpin,
replacement in src/xmpp/mod.rs at line 40

[3.4357]→[3.39400:39431](∅→∅)

let conn = account.into();

[3.4357]

[3.41154]

use futures_util::StreamExt;
replacement in src/xmpp/mod.rs at line 42

[3.41155]→[3.39432:39536](∅→∅),[3.39536]→[3.4617:4692](∅→∅),[3.6003]→[3.4617:4692](∅→∅),[3.10535]→[3.4617:4692](∅→∅),[3.4267]→[3.4617:4692](∅→∅),[3.6190]→[3.4617:4692](∅→∅),[3.6395]→[3.4617:4692](∅→∅),[3.5794]→[3.4617:4692](∅→∅),[3.41291]→[3.4617:4692](∅→∅),[3.23609]→[3.4617:4692](∅→∅),[3.5149]→[3.4617:4692](∅→∅),[3.6154]→[3.4617:4692](∅→∅),[3.4617]→[3.4617:4692](∅→∅),[3.4692]→[3.39537:40205](∅→∅),[3.40205]→[3.42901:43045](∅→∅),[3.67274]→[3.40349:40577](∅→∅),[3.43045]→[3.40349:40577](∅→∅),[3.40349]→[3.40349:40577](∅→∅)

future::loop_fn(XmppProcessState::new(cmd_recv, signal, conn), |s| {
let XmppProcessState {
cmd_recv,
signal,
conn,
} = s;
conn.connect(signal.clone()).and_then(|conn| {
info!("xmpp connected!");
conn.processing(|_, _| Ok(false), cmd_recv.into_future())
.then(|r| match r {
Ok((mut conn, r)) => match r {
Ok(Either::A(f)) => {
if let Some(cmd_recv) = f.into_inner() {
future::ok(future::Loop::Continue(XmppProcessState {
cmd_recv,
signal,
conn: conn.into(),
}))
} else {
error!("Command receiver is gone");
future::ok(future::Loop::Break(Some(conn)))
}
}
Ok(Either::B((cmd, cmd_recv))) => {
if let Some(cmd) = cmd {
conn.process_command(cmd);

[3.41155]

[3.40577]

let mut maybe_conn: MaybeXmppConnection = account.into();
let mut recv_future = cmd_recv.next();
replacement in src/xmpp/mod.rs at line 45

[3.40578]→[3.40578:40881](∅→∅),[3.40578]→[3.40578:40881](∅→∅),[3.40578]→[3.40578:40881](∅→∅),[3.40881]→[3.43046:43122](∅→∅),[3.67343]→[3.40957:41013](∅→∅),[3.43122]→[3.40957:41013](∅→∅),[3.40957]→[3.40957:41013](∅→∅),[3.41013]→[3.43123:43323](∅→∅),[3.67434]→[3.41213:42353](∅→∅),[3.43323]→[3.41213:42353](∅→∅),[3.41213]→[3.41213:42353](∅→∅),[3.42353]→[3.43324:43394](∅→∅),[3.67503]→[3.42423:42622](∅→∅),[3.43394]→[3.42423:42622](∅→∅),[3.42423]→[3.42423:42622](∅→∅),[3.42622]→[3.43395:43601](∅→∅)

future::ok(future::Loop::Continue(XmppProcessState {
cmd_recv,
signal,
conn: conn.into(),
}))
} else {
future::ok(future::Loop::Break(Some(conn)))
}
}
Err(_) => {
error!("Command receiver is broken");
future::ok(future::Loop::Break(Some(conn)))
}
},
Err((account, r)) => match r {
Ok(Either::A(f)) => {
if let Some(cmd_recv) = f.into_inner() {
future::ok(future::Loop::Continue(XmppProcessState {
cmd_recv,
signal,
conn: account.into(),
}))
} else {
future::err(format_err!("Command receiver is gone"))
}
}
Ok(Either::B((cmd, cmd_recv))) => {
if let Some(_cmd) = cmd {
error!("Xmpp connection broken while get command");
future::ok(future::Loop::Continue(XmppProcessState {
cmd_recv,
signal,
conn: account.into(),
}))
} else {
future::ok(future::Loop::Break(None))
}
}
Err(_) => future::err(format_err!("Command receiver is broken")),
},
})
})
})
.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(()))

[3.40578]

[3.43601]

loop {
match maybe_conn.connect(signal.clone()).await {
Ok(conn) => match conn.processing(|_, _| Ok(false), recv_future, false).await {
(Ok(conn), Either::Left(f)) => {
maybe_conn = conn.into();
recv_future = f;
}
(Ok(conn), Either::Right(None)) => break Ok(()),
(Ok(conn), Either::Right(Some(cmd))) => {
info!("Get command: {:?}", cmd);
maybe_conn = conn.process_command(cmd);
recv_future = cmd_recv.next();
}
(Err(acc), Either::Left(f)) => {
maybe_conn = acc.into();
recv_future = f;
}
(Err(acc), Either::Right(None)) => break Ok(()),
(Err(acc), Either::Right(Some(cmd))) => {
warn!("Get command for broken connection: {:?}", cmd);
maybe_conn = acc.into();
recv_future = cmd_recv.next();
}
},
Err(e) => break Err(e),
replacement in src/xmpp/mod.rs at line 71

[3.43611]→[3.42838:42845](∅→∅),[3.42838]→[3.42838:42845](∅→∅)

})

[3.43611]

[3.7379]

}
replacement in src/xmpp/element_processor.rs at line 0

[3.11301]→[2.37175:38251](∅→∅)

type Func<S, T, E> = dyn Fn(&mut S, E) -> T;

pub struct Processor<S: 'static, T: 'static, E: Clone + 'static> {
processors: Vec<Box<Func<S, Option<T>, E>>>,
default: &'static Func<S, T, E>,
}

impl<S: 'static, T: 'static, E: Clone + 'static> Processor<S, T, E> {
pub fn new<F>(f: &'static F) -> Processor<S, T, E>
where
F: Fn(&mut S, E) -> T + 'static,
{
Processor {
processors: vec![],
default: f,
}
}

pub fn register<F, A>(&mut self, f: &'static F)
where
F: Fn(&mut S, A) -> T + 'static,
A: std::convert::TryFrom<E>,
{
self.processors.push(Box::new(move |s, e: E| {
use std::convert::TryInto;
(e.try_into().ok() as Option<A>).map(|a| f(s, a))
}));
}

pub fn process(&self, s: &mut S, e: E) -> T {
for processor in self.processors.iter() {
match processor(s, e.clone()) {
Some(t) => return t,
None => continue,
}
}
(*self.default)(s, e)
}
}

[3.11301]

type Func<S, T, E> = dyn Fn(&mut S, E) -> T + Sync;

pub struct Processor<S: 'static, T: 'static, E: Clone + 'static> {
processors: Vec<Box<Func<S, Option<T>, E>>>,
default: &'static Func<S, T, E>,
}

impl<S: 'static, T: 'static, E: Clone + 'static> Processor<S, T, E> {
pub fn new<F>(f: &'static F) -> Processor<S, T, E>
where
F: Fn(&mut S, E) -> T + Sync + 'static,
{
Processor {
processors: vec![],
default: f,
}
}

pub fn register<F, A>(&mut self, f: &'static F)
where
F: Fn(&mut S, A) -> T + Sync + '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)
}
}
replacement in src/stoppable_receiver.rs at line 0

[3.450]→[3.43944:43965](∅→∅)

use std::fmt::Debug;

[3.450]

[3.43965]

use std::future::Future;
use std::pin::Pin;

use tokio::stream::Stream;
use tokio::sync::mpsc::Receiver;
replacement in src/stoppable_receiver.rs at line 6

[3.43966]→[3.473:559](∅→∅),[3.473]→[3.473:559](∅→∅)

use tokio::prelude::{Async, Future, Poll, Stream};
use tokio_channel::mpsc::Receiver;

[3.43966]

[3.559]

use pin_project::pin_project;
replacement in src/stoppable_receiver.rs at line 8

[3.560]→[3.560:618](∅→∅),[3.560]→[3.560:618](∅→∅)

pub struct StoppableReceiver<T, F>
where
F: Future,
{

[3.560]

[3.618]

#[pin_project(project = StoppableReceiverProj)]
pub struct StoppableReceiver<T, F: Future<Output = ()>> {
#[pin]
edit in src/stoppable_receiver.rs at line 12

[3.645]

[3.645]

#[pin]
replacement in src/stoppable_receiver.rs at line 17

[3.688]→[3.688:755](∅→∅),[3.688]→[3.688:755](∅→∅),[3.755]→[3.43967:43981](∅→∅),[3.43981]→[3.769:771](∅→∅),[3.769]→[3.769:771](∅→∅)

impl<T, F> Stream for StoppableReceiver<T, F>
where
F: Future,
T: Debug,
{

[3.688]

[3.771]

impl<T, F: Future<Output = ()>> Stream for StoppableReceiver<T, F> {
edit in src/stoppable_receiver.rs at line 19

[3.790]→[3.790:811](∅→∅),[3.790]→[3.790:811](∅→∅)

type Error = ();
replacement in src/stoppable_receiver.rs at line 20

[3.812]→[3.812:1281](∅→∅),[3.812]→[3.812:1281](∅→∅)

fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
if !self.finished {
match self.stop_future.poll() {
Err(_) => {
self.receiver.close();
self.finished = true;
}
Ok(Async::Ready(_)) => {
self.receiver.close();
self.finished = true;
}
Ok(Async::NotReady) => {}
}

[3.812]

[3.1281]

fn poll_next(
self: Pin<&mut Self>,
cx: &mut std::task::Context,
) -> std::task::Poll<Option<Self::Item>> {
let StoppableReceiverProj {
mut receiver,
stop_future,
finished,
} = self.project();

if *finished {
return std::task::Poll::Ready(None);
}

if let std::task::Poll::Ready(_) = stop_future.poll(cx) {
*finished = true;
receiver.close();
return std::task::Poll::Ready(None);
replacement in src/stoppable_receiver.rs at line 40

[3.1292]→[3.43982:44011](∅→∅)

self.receiver.poll()

[3.1292]

[3.1322]

receiver.poll_recv(cx)
replacement in src/stoppable_receiver.rs at line 44

[3.1331]→[3.1331:1445](∅→∅),[3.1331]→[3.1331:1445](∅→∅),[3.1331]→[3.1331:1445](∅→∅),[3.1331]→[3.1331:1445](∅→∅),[3.1331]→[3.1331:1445](∅→∅),[3.1331]→[3.1331:1445](∅→∅),[3.1445]→[3.44012:44026](∅→∅),[3.44026]→[3.1459:1461](∅→∅),[3.1459]→[3.1459:1461](∅→∅)

pub fn stop_receiver<T, F>(receiver: Receiver<T>, stop_future: F) -> StoppableReceiver<T, F>
where
F: Future,
T: Debug,
{

[3.1331]

[3.1461]

pub fn stop_receiver<T, F: Future<Output = ()>>(
receiver: Receiver<T>,
stop_future: F,
) -> StoppableReceiver<T, F> {
edit in src/main.rs at line 6

[3.40916]→[3.40916:40955](∅→∅),[3.40916]→[3.40916:40955](∅→∅),[3.45073]→[3.40955:41151](∅→∅),[3.40955]→[3.40955:41151](∅→∅),[3.41151]→[3.44057:44092](∅→∅),[3.44092]→[3.41186:41232](∅→∅),[3.41186]→[3.41186:41232](∅→∅),[3.44132]→[3.41232:41233](∅→∅),[3.37209]→[3.41232:41233](∅→∅),[3.35284]→[3.41232:41233](∅→∅),[3.44749]→[3.41232:41233](∅→∅),[3.41232]→[3.41232:41233](∅→∅)

extern crate clap;
extern crate hyper;
#[macro_use]
extern crate log;
extern crate env_logger;
#[macro_use]
extern crate serde_derive;
extern crate tokio;
extern crate tokio_channel;
extern crate tokio_signal;
extern crate tokio_xmpp;
#[macro_use]
extern crate failure;
extern crate toml;
extern crate xmpp_parsers;
replacement in src/main.rs at line 8

[3.41280]→[3.41280:41345](∅→∅),[3.41280]→[3.41280:41345](∅→∅)

use tokio::runtime::current_thread;
use tokio::runtime::Runtime;

[3.41280]

[3.41345]

use log::{error, info, warn};
edit in src/main.rs at line 10

[3.41346]→[3.44133:44177](∅→∅),[3.44177]→[3.41390:41391](∅→∅),[3.45133]→[3.41390:41391](∅→∅),[3.41390]→[3.41390:41391](∅→∅)

use tokio::prelude::{Future, Sink, Stream};
replacement in src/main.rs at line 19

[3.44300]→[3.44300:44414](∅→∅)

fn body_to_string(req: Request<Body>) -> impl Future<Item = String, Error = failure::Error> {
req.into_body()

[3.44300]

[3.44750]

/// Return future with body converted to String
async fn body_to_string(req: Request<Body>) -> Result<String, failure::Error> {
let whole_body = hyper::body::to_bytes(req.into_body()).await?;
std::str::from_utf8(&whole_body)
.map(std::string::ToString::to_string)
edit in src/main.rs at line 25

[3.68633]→[3.44457:44629](∅→∅),[3.44793]→[3.44457:44629](∅→∅),[3.44457]→[3.44457:44629](∅→∅)

.fold(String::new(), |mut acc, ch| {
std::str::from_utf8(&*ch).map(|s| {
acc.push_str(s);
acc
})
})
replacement in src/main.rs at line 28

[3.44652]→[3.44652:44708](∅→∅),[3.44652]→[3.44652:44708](∅→∅),[3.44652]→[3.44652:44708](∅→∅)

cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,

[3.44652]

[3.44708]

cmd_send: tokio::sync::mpsc::Sender<XmppCommand>,
replacement in src/main.rs at line 31

[3.44711]→[3.44711:44807](∅→∅),[3.44711]→[3.44711:44807](∅→∅),[3.44711]→[3.44711:44807](∅→∅)

impl hyper::service::Service for ServiceCmd {
type ReqBody = Body;
type ResBody = Body;

[3.44711]

[3.44807]

impl hyper::service::Service<Request<Body>> for ServiceCmd {
type Response = Response<Body>;
replacement in src/main.rs at line 34

[3.44840]→[3.44840:44953](∅→∅),[3.44840]→[3.44840:44953](∅→∅),[3.44840]→[3.44840:44953](∅→∅)

type Future =
Box<dyn Future<Item = Response<Self::ResBody>, Error = Self::Error> + Send + 'static>;

[3.44840]

[3.44953]

type Future = std::pin::Pin<
Box<dyn std::future::Future<Output = Result<Self::Response, Self::Error>> + Send>,
>;

fn poll_ready(
&mut self,
_: &mut std::task::Context,
) -> std::task::Poll<Result<(), Self::Error>> {
std::task::Poll::Ready(Ok(()))
}
replacement in src/main.rs at line 45

[3.44954]→[3.44954:45024](∅→∅),[3.44954]→[3.44954:45024](∅→∅),[3.44954]→[3.44954:45024](∅→∅)

fn call(&mut self, req: Request<Self::ReqBody>) -> Self::Future {

[3.44954]

[3.45024]

fn call(&mut self, req: Request<Body>) -> Self::Future {
replacement in src/main.rs at line 48

[3.45176]→[3.45176:45232](∅→∅),[3.45176]→[3.45176:45232](∅→∅),[3.45176]→[3.45176:45232](∅→∅)

|| Err(format_err!("No X-XMPP-To header")),

[3.45176]

[3.45232]

|| Err(failure::format_err!("No X-XMPP-To header")),
replacement in src/main.rs at line 61

[2.38253]→[2.38253:38345](∅→∅)

let xmpp_pres_opt = req
.headers()
.get("X-XMPP-Presence");

[2.38253]

[2.38345]

let xmpp_pres_opt = req.headers().get("X-XMPP-Presence");
replacement in src/main.rs at line 63

[2.38441]→[2.38441:38816](∅→∅)

.map_or_else(|| Err(format_err!("No X-XMPP-Presence header")),
|show| {
std::str::from_utf8(show.as_bytes())
.map_err(std::convert::Into::into)
.and_then(|s| std::str::FromStr::from_str(s)
.map_err(|e| format_err!("Incorrect presence {}", e) ))
},
);

[2.38441]

[3.45651]

.map_or_else(
|| Err(failure::format_err!("No X-XMPP-Presence header")),
|show| {
std::str::from_utf8(show.as_bytes())
.map_err(std::convert::Into::into)
.and_then(|s| {
std::str::FromStr::from_str(s)
.map_err(|e| failure::format_err!("Incorrect presence {}", e))
})
},
);
replacement in src/main.rs at line 79

[2.38979]→[3.45785:45842](∅→∅),[3.45785]→[3.45785:45842](∅→∅)

Box::new(tokio::prelude::future::result(

[2.38979]

[3.45842]

Box::pin(async move {
replacement in src/main.rs at line 83

[2.39030]→[2.39030:39177](∅→∅)

"Unknown destination: {}\nUnknown destination: {}",
err,
err2,

[2.39030]

[2.39177]

"Unknown destination: {}\nUnknown destination2: {}",
err, err2,
replacement in src/main.rs at line 86

[2.39205]→[3.45023:45083](∅→∅),[3.46029]→[3.45023:45083](∅→∅),[3.68978]→[3.46089:46165](∅→∅),[3.45083]→[3.46089:46165](∅→∅),[3.46089]→[3.46089:46165](∅→∅)

.map_err(std::convert::Into::into),
)) as Box<dyn Future<Item = _, Error = _> + Send + 'static>

[2.39205]

[3.46165]

.map_err(std::convert::Into::into)
})
replacement in src/main.rs at line 91

[2.39307]→[2.39307:41398](∅→∅),[2.41398]→[3.46216:47605](∅→∅),[3.46216]→[3.46216:47605](∅→∅),[3.47605]→[3.45084:45152](∅→∅),[3.69035]→[3.47673:48028](∅→∅),[3.45152]→[3.47673:48028](∅→∅),[3.47673]→[3.47673:48028](∅→∅),[3.48028]→[3.45153:45221](∅→∅),[3.69092]→[3.48096:48321](∅→∅),[3.45221]→[3.48096:48321](∅→∅),[3.48096]→[3.48096:48321](∅→∅),[3.48321]→[2.41399:43625](∅→∅),[2.43625]→[3.48360:49756](∅→∅),[3.48360]→[3.48360:49756](∅→∅),[3.49756]→[3.45222:45290](∅→∅),[3.69149]→[3.49824:50179](∅→∅),[3.45290]→[3.49824:50179](∅→∅),[3.49824]→[3.49824:50179](∅→∅),[3.50179]→[3.45291:45359](∅→∅),[3.69206]→[3.50247:50359](∅→∅),[3.45359]→[3.50247:50359](∅→∅),[3.50247]→[3.50247:50359](∅→∅)

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::Presence { show, 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>
}
(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)), _, Ok(show)) => {
info!("Got MUC presence 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::ChatroomPresence { muc_id, show, 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>

[2.39307]

[3.50359]

let mut cmd_send = self.cmd_send.clone();
Box::pin(async move {
match body_to_string(req).await {
Ok(message) => {
match cmd_send.send(XmppCommand::Presence { show, message }).await {
Ok(_) => Response::builder()
.body(Body::from(format!("Accepted")))
.map_err(std::convert::Into::into),
Err(e) => {
error!("Cann't send presence command: {}", e);
Response::builder()
.status(hyper::StatusCode::BAD_REQUEST)
.body(Body::from(format!("Cann't get presence text")))
.map_err(std::convert::Into::into)
}
}
}
Err(e) => Response::builder()
.status(hyper::StatusCode::BAD_REQUEST)
.body(Body::from(format!("Cann't get presence text")))
.map_err(std::convert::Into::into),
replacement in src/main.rs at line 113

[3.50381]→[3.50381:50458](∅→∅),[3.50381]→[3.50381:50458](∅→∅),[3.50381]→[3.50381:50458](∅→∅)

})) as Box<dyn Future<Item = _, Error = _> + Send + 'static>

[3.50381]

[3.50458]

})
replacement in src/main.rs at line 115

[3.50472]→[2.43626:43666](∅→∅),[2.43666]→[3.50509:50816](∅→∅),[3.50509]→[3.50509:50816](∅→∅),[3.50816]→[3.45360:45420](∅→∅),[3.69255]→[3.50876:50966](∅→∅),[3.45420]→[3.50876:50966](∅→∅),[3.50876]→[3.50876:50966](∅→∅)

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

[3.50472]

[3.50966]

(None, Ok(xmpp_to), _) => Box::pin(async {
Response::builder()
.status(hyper::StatusCode::BAD_REQUEST)
.body(Body::from(format!("SOON")))
.map_err(std::convert::Into::into)
}),
(Some(Ok(muc_id)), _, Ok(show)) => Box::pin(async {
Response::builder()
.status(hyper::StatusCode::BAD_REQUEST)
.body(Body::from(format!("SOON")))
.map_err(std::convert::Into::into)
}),
(Some(Ok(muc_id)), _, _) => Box::pin(async {
Response::builder()
.status(hyper::StatusCode::BAD_REQUEST)
.body(Body::from(format!("SOON")))
.map_err(std::convert::Into::into)
}),
(Some(Err(err)), _, _) => Box::pin(async {
Response::builder()
.status(hyper::StatusCode::BAD_REQUEST)
.body(Body::from(format!("SOON")))
.map_err(std::convert::Into::into)
}),
replacement in src/main.rs at line 144

[3.51009]→[3.51009:51065](∅→∅),[3.51009]→[3.51009:51065](∅→∅),[3.51009]→[3.51009:51065](∅→∅)

cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,

[3.51009]

[3.51065]

cmd_send: tokio::sync::mpsc::Sender<XmppCommand>,
replacement in src/main.rs at line 147

[3.51068]→[3.51068:51182](∅→∅),[3.51068]→[3.51068:51182](∅→∅),[3.51068]→[3.51068:51182](∅→∅)

impl<Ctx> hyper::service::MakeService<Ctx> for MakeServiceCmd {
type ReqBody = Body;
type ResBody = Body;

[3.51068]

[3.51182]

impl<T> hyper::service::Service<T> for MakeServiceCmd {
type Response = ServiceCmd;
replacement in src/main.rs at line 150

[3.51215]→[3.51215:51372](∅→∅),[3.51215]→[3.51215:51372](∅→∅),[3.51215]→[3.51215:51372](∅→∅)

type Service = ServiceCmd;
type Future = tokio::prelude::future::FutureResult<ServiceCmd, Self::MakeError>;
type MakeError = hyper::http::Error;

[3.51215]

[3.48631]

type Future = std::pin::Pin<
Box<dyn std::future::Future<Output = Result<Self::Response, Self::Error>> + Send>,
>;

fn poll_ready(
&mut self,
_: &mut std::task::Context,
) -> std::task::Poll<Result<(), Self::Error>> {
std::task::Poll::Ready(Ok(()))
}
replacement in src/main.rs at line 161

[3.48632]→[3.51373:51537](∅→∅)

fn make_service(&mut self, _ctx: Ctx) -> Self::Future {
tokio::prelude::future::ok(ServiceCmd {
cmd_send: self.cmd_send.clone(),
})

[3.48632]

[3.51537]

fn call(&mut self, _: T) -> Self::Future {
let cmd_send = self.cmd_send.clone();
let fut = async move { Ok(ServiceCmd { cmd_send }) };
Box::pin(fut)
replacement in src/main.rs at line 168

[3.51546]→[3.18:30](∅→∅),[3.14016]→[3.18:30](∅→∅),[3.18716]→[3.18:30](∅→∅),[3.4180]→[3.18:30](∅→∅),[3.4261]→[3.18:30](∅→∅),[3.435]→[3.18:30](∅→∅),[3.9739]→[3.18:30](∅→∅),[3.13644]→[3.18:30](∅→∅),[3.31334]→[3.18:30](∅→∅),[3.2896]→[3.18:30](∅→∅),[3.48805]→[3.18:30](∅→∅),[3.4702]→[3.18:30](∅→∅),[3.5634]→[3.18:30](∅→∅),[3.33338]→[3.18:30](∅→∅),[3.17]→[3.18:30](∅→∅)

fn main() {

[3.51546]

[3.48806]

/// Entry point of daemon
#[tokio::main]
pub async fn main() -> Result<(), failure::Error> {
replacement in src/main.rs at line 189

[3.49351]→[3.30988:31025](∅→∅),[3.47758]→[3.49388:49498](∅→∅),[3.30839]→[3.49388:49498](∅→∅),[3.31025]→[3.49388:49498](∅→∅),[3.49388]→[3.49388:49498](∅→∅),[3.49498]→[3.51672:51779](∅→∅),[3.51779]→[3.49605:49624](∅→∅),[3.45416]→[3.49605:49624](∅→∅),[3.49605]→[3.49605:49624](∅→∅)

use hyper::rt::{Future, Stream};
let ctrl_c = tokio_signal::ctrl_c()
.flatten_stream()
.into_future()
.map(|_| ())
.map_err(|e| {
error!("Cann't get CTRL+C signal: {}", e.0);
e.0
})
.shared();

[3.49351]

[3.49624]

use futures_util::future::FutureExt;
let ctrl_c = async {
tokio::signal::ctrl_c().await;
}
.shared();
replacement in src/main.rs at line 195

[3.49625]→[3.49625:49690](∅→∅),[3.49625]→[3.49625:49690](∅→∅),[3.49625]→[3.49625:49690](∅→∅)

let (cmd_send, cmd_recv) = tokio_channel::mpsc::channel(10);

[3.49625]

[3.49690]

let (mut cmd_send, cmd_recv) = tokio::sync::mpsc::channel(10);
replacement in src/main.rs at line 201

[3.69300]→[3.51863:51923](∅→∅),[3.45504]→[3.51863:51923](∅→∅),[3.51863]→[3.51863:51923](∅→∅),[3.51923]→[3.49883:49936](∅→∅),[3.46248]→[3.49883:49936](∅→∅),[3.49883]→[3.49883:49936](∅→∅)

.with_graceful_shutdown(ctrl_c.clone().map(|_| ()))
.map_err(|e| error!("server error: {}", e));

[3.45504]

[3.49936]

.with_graceful_shutdown(ctrl_c.clone());
edit in src/main.rs at line 203

[3.49937]→[3.49937:50000](∅→∅),[3.49937]→[3.49937:50000](∅→∅),[3.49937]→[3.49937:50000](∅→∅)

let mut rt = Runtime::new().expect("Cann't start tokio");
replacement in src/main.rs at line 204

[3.45551]→[3.45551:46310](∅→∅)

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

[3.45551]

[3.46310]

let mut ping = tokio::time::interval(std::time::Duration::from_secs(ping));
let mut ctrl_c = ctrl_c.clone();
tokio::spawn(async move {
loop {
let tick = ping.tick();
tokio::pin!(tick);
match futures_util::future::select(ctrl_c, tick).await {
futures_util::future::Either::Left((_, _)) => break,
futures_util::future::Either::Right((_, ctrl_c__)) => {
ctrl_c = ctrl_c__;
info!("Tick");
cmd_send.clone().send(XmppCommand::Ping).await;
cmd_send.send(XmppCommand::TimeoutCleanup).await;
}
}
}
});
replacement in src/main.rs at line 223

[3.52736]→[3.50812:50840](∅→∅),[3.46317]→[3.50812:50840](∅→∅),[3.50812]→[3.50812:50840](∅→∅),[3.50840]→[3.52737:52816](∅→∅),[3.52816]→[3.50919:51089](∅→∅),[3.46330]→[3.50919:51089](∅→∅),[3.50919]→[3.50919:51089](∅→∅),[3.51089]→[3.52817:52905](∅→∅),[3.52905]→[3.51177:51239](∅→∅),[3.46478]→[3.51177:51239](∅→∅),[3.51177]→[3.51177:51239](∅→∅)

rt.spawn(http_server);

let xmpp_join = std::thread::spawn(move || -> Result<(), failure::Error> {
let recv = stop_receiver(cmd_recv, ctrl_c.clone().map(|_| ()));
// Launch single-threaded runtime
let mut ctrt = current_thread::Runtime::new()?;
let result = ctrt.block_on(xmpp_process(ctrl_c.clone(), recv, config.account));
info!("Stopping xmpp thread");
result
});

[3.46317]

[3.51239]

let xmpp_join = std::thread::Builder::new()
.name("XMPP Thread".into())
.spawn(move || -> Result<(), failure::Error> {
let recv = stop_receiver(cmd_recv, ctrl_c.clone());
// Launch single-threaded runtime
let mut ctrt = tokio::runtime::Builder::new()
.basic_scheduler()
.enable_time()
.enable_io()
.build()?;
let result = ctrt.block_on(xmpp_process(ctrl_c.clone(), recv, config.account));
info!("Stopping xmpp thread");
result
})
.expect("XMPP Thread");
replacement in src/main.rs at line 241

[3.51270]→[3.51270:51329](∅→∅),[3.51270]→[3.51270:51329](∅→∅),[3.51270]→[3.51270:51329](∅→∅)

rt.shutdown_on_idle().wait().expect("Shutdown error");

[3.51270]

[3.51329]

http_server.await;
replacement in src/main.rs at line 245

[3.51360]→[3.51360:51465](∅→∅),[3.51360]→[3.51360:51465](∅→∅),[3.51360]→[3.51360:51465](∅→∅)

xmpp_join
.join()
.expect("Join xmpp thread")
.expect("Result xmpp thread");

[3.51360]

[3.61]

xmpp_join.join().unwrap();

Ok(())
edit in src/config.rs at line 4

[3.1450]

[3.1450]

use serde_derive::Deserialize;
replacement in README.md at line 0

[3.76]→[3.68794:68817](∅→∅)

### XMPP client daemon

[3.76]

[3.39360]

# XMPP client daemon

## XMPP

### XMPP Core

Ensures granted subscription before delivering messages

### XEPs

#### XEP-0030: Service Discovery

Answers to `http://jabber.org/protocol/disco#info` query.
Answers to `http://jabber.org/protocol/disco#items` query.

#### XEP-0045: Multi-User Chat

Enters to all MUC in `account.chatrooms` at start.

#### XEP-0050: Ad-Hoc Commands

Answers empty commands list. (Awaiting for implementation in xmpp_parser).

#### XEP-0092: Software Version

Answers version.

#### XEP-0199: XMPP Ping

Sends ping each `account.ping` seconds to XMPP server.

Answers to incoming pings.

#### XEP-0203: Delayed Delivery

Ignores delayed messages.
replacement in README.md at line 37

[3.39361]→[3.68818:68840](∅→∅)

#### Sending messages

[3.39361]

[3.39394]

## HTTP API
edit in README.md at line 39

[3.39395]

[3.54303]

### Sending messages
replacement in README.md at line 45

[3.54382]→[3.68841:68870](∅→∅)

#### Sending messages to MUC

[3.54382]

[3.54411]

### Sending messages to MUC
replacement in Cargo.toml at line 9

[3.12187]→[3.52639:52696](∅→∅),[3.52696]→[3.54500:54539](∅→∅),[3.54539]→[3.52735:52750](∅→∅),[3.46585]→[3.52735:52750](∅→∅),[3.52735]→[3.52735:52750](∅→∅)

tokio = "0.1"
tokio-channel = "0.1"
tokio-signal = "0.2"
tokio-xmpp = "1.0.0"
failure = "0.1.5"
hyper = "0.12"

[3.12187]

[3.37242]

futures-util = "0.3.5"
tokio-xmpp = { git = "https://gitlab.com/xmpp-rs/xmpp-rs" }
failure = "0.1.8"
hyper = "0.13"
replacement in Cargo.toml at line 16

[3.52798]→[3.52798:52812](∅→∅),[3.52798]→[3.52798:52812](∅→∅),[3.52798]→[3.52798:52812](∅→∅),[3.52798]→[3.52798:52812](∅→∅),[3.52798]→[3.52798:52812](∅→∅),[3.52798]→[3.52798:52812](∅→∅),[3.52798]→[3.52798:52812](∅→∅)

clap = "2.32"

[3.52798]

[3.52812]

clap = "2.33"
replacement in Cargo.toml at line 18

[3.52824]→[3.54554:54573](∅→∅),[3.54573]→[3.37256:37278](∅→∅),[3.48414]→[3.54595:54630](∅→∅),[3.69592]→[3.54595:54630](∅→∅),[3.37278]→[3.54595:54630](∅→∅),[3.47563]→[3.54595:54630](∅→∅),[3.54595]→[3.54595:54630](∅→∅)

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

[3.52824]

env_logger = "0.7"
xmpp-parsers = "0.17"
minidom = "=0.12.0" # xmpp-parsers
lazy_static = "1.4.0" # ToDo: remove after const fn will be powerfull enough
pin-project = "0.4"

[dependencies.tokio]
version = "0.2"
features = ["signal", "sync", "rt-threaded"]

[patch.crates-io]
xmpp-parsers = { git = "https://gitlab.com/xmpp-rs/xmpp-rs" }
minidom = { git = "https://gitlab.com/xmpp-rs/xmpp-rs" }
replacement in Cargo.lock at line 3

[3.31038]→[3.31038:31078](∅→∅)

name = "MacTypes-sys"
version = "2.1.0"

[3.31038]

[3.31078]

name = "addr2line"
version = "0.13.0"
replacement in Cargo.lock at line 7

[3.31160]→[3.31160:31232](∅→∅)

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

[3.31160]

[3.31232]

"gimli 0.22.0 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 9

[3.31234]

[3.31234]

[[package]]
name = "adler"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
replacement in Cargo.lock at line 17

[3.53235]→[3.37357:37375](∅→∅)

version = "0.7.3"

[3.53235]

[3.53253]

version = "0.7.13"
replacement in Cargo.lock at line 20

[3.53335]→[3.47826:47899](∅→∅)

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

[3.53335]

[3.53408]

"memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 28

[3.53543]→[3.37376:37449](∅→∅)

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

[3.53543]

[3.53616]

"winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 33

[3.53649]→[3.31236:31255](∅→∅)

version = "0.3.10"

[3.53649]

[3.46847]

version = "0.4.7"
replacement in Cargo.lock at line 37

[3.53746]→[3.53746:53764](∅→∅),[3.53764]→[3.55196:55215](∅→∅)

name = "arrayvec"
version = "0.4.10"

[3.46925]

[3.53783]

name = "async-trait"
version = "0.1.40"
replacement in Cargo.lock at line 41

[3.53865]→[3.55216:55290](∅→∅)

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

[3.53865]

[3.53939]

"proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
"syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 48

[3.53968]→[3.53968:53987](∅→∅),[3.53968]→[3.53968:53987](∅→∅),[3.53968]→[3.53968:53987](∅→∅)

version = "0.2.11"

[3.53968]

[3.53987]

version = "0.2.14"
replacement in Cargo.lock at line 51

[3.54069]→[3.31256:31402](∅→∅),[3.31402]→[3.37616:37689](∅→∅),[3.37616]→[3.37616:37689](∅→∅)

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

[3.54069]

[3.54288]

"hermit-abi 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 58

[3.55455]→[3.31403:31421](∅→∅)

version = "0.1.2"

[3.55455]

[3.54338]

version = "1.0.1"
replacement in Cargo.lock at line 63

[3.54435]→[3.31422:31441](∅→∅)

version = "0.3.15"

[3.54435]

[3.54454]

version = "0.3.50"
replacement in Cargo.lock at line 66

[3.54536]→[3.31442:31516](∅→∅),[3.31516]→[3.55568:55649](∅→∅),[3.37803]→[3.55568:55649](∅→∅),[3.55568]→[3.55568:55649](∅→∅),[3.55649]→[3.31517:31817](∅→∅)

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

[3.54536]

[3.54991]

"addr2line 0.13.0 (registry+https://github.com/rust-lang/crates.io-index)",
"cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
"miniz_oxide 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
"object 0.20.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc-demangle 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 75

[3.55006]→[3.55006:55029](∅→∅),[3.55006]→[3.55006:55029](∅→∅),[3.55006]→[3.55006:55029](∅→∅),[3.55006]→[3.55006:55029](∅→∅),[3.55006]→[3.55006:55029](∅→∅),[3.55006]→[3.55006:55029](∅→∅),[3.55006]→[3.55006:55029](∅→∅),[3.55006]→[3.55006:55029](∅→∅),[3.55029]→[3.55950:55969](∅→∅)

name = "backtrace-sys"
version = "0.1.28"

[3.55006]

[3.55048]

name = "base64"
version = "0.10.1"
replacement in Cargo.lock at line 79

[3.55130]→[3.31818:31960](∅→∅)

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

[3.55130]

[3.55272]

"byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 84

[3.55303]→[3.56113:56132](∅→∅)

version = "0.10.1"

[3.55303]

[3.55322]

version = "0.12.3"
edit in Cargo.lock at line 86

[3.55387]→[3.55387:55404](∅→∅),[3.55387]→[3.55387:55404](∅→∅),[3.55387]→[3.55387:55404](∅→∅),[3.55404]→[3.31961:32037](∅→∅),[3.56209]→[3.55480:55482](∅→∅),[3.48530]→[3.55480:55482](∅→∅),[3.32037]→[3.55480:55482](∅→∅),[3.38251]→[3.55480:55482](∅→∅),[3.55480]→[3.55480:55482](∅→∅)

dependencies = [
"byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 89

[3.55513]→[3.32038:32056](∅→∅)

version = "1.0.4"

[3.55513]

[3.55531]

version = "1.2.1"
replacement in Cargo.lock at line 94

[3.55625]→[3.56210:56228](∅→∅)

version = "0.8.0"

[3.55625]

[3.55643]

version = "0.8.1"
replacement in Cargo.lock at line 99

[3.56383]→[3.56383:56535](∅→∅)

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

[3.56383]

[3.56031]

"digest 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
"opaque-debug 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 105

[3.56068]→[3.32057:32075](∅→∅)

version = "0.7.0"

[3.56068]

[3.56538]

version = "0.7.3"
replacement in Cargo.lock at line 108

[3.56620]→[3.32076:32156](∅→∅)

"block-padding 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",

[3.56620]

[3.56635]

"block-padding 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 110

[3.56712]→[3.32157:32233](∅→∅),[3.32233]→[3.56788:56869](∅→∅),[3.38447]→[3.56788:56869](∅→∅),[3.56788]→[3.56788:56869](∅→∅)

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

[3.56712]

[3.56869]

"byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
"generic-array 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 116

[3.56907]→[3.32234:32252](∅→∅)

version = "0.1.3"

[3.56907]

[3.56925]

version = "0.1.5"
replacement in Cargo.lock at line 129

[3.56847]→[3.32253:32271](∅→∅)

version = "1.3.1"

[3.56847]

[3.56865]

version = "1.3.4"
replacement in Cargo.lock at line 134

[3.56958]→[3.38486:38505](∅→∅)

version = "0.4.12"

[3.56958]

[3.56977]

version = "0.5.6"
edit in Cargo.lock at line 136

[3.57042]→[3.57042:57059](∅→∅),[3.57042]→[3.57042:57059](∅→∅),[3.57042]→[3.57042:57059](∅→∅),[3.57042]→[3.57042:57059](∅→∅),[3.57042]→[3.57042:57059](∅→∅),[3.57042]→[3.57042:57059](∅→∅),[3.57042]→[3.57042:57059](∅→∅),[3.57059]→[3.32272:32348](∅→∅),[3.57219]→[3.57135:57209](∅→∅),[3.49084]→[3.57135:57209](∅→∅),[3.32348]→[3.57135:57209](∅→∅),[3.38655]→[3.57135:57209](∅→∅),[3.57135]→[3.57135:57209](∅→∅)

dependencies = [
"byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
"iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
edit in Cargo.lock at line 138

[3.57222]→[3.57222:57332](∅→∅),[3.57222]→[3.57222:57332](∅→∅),[3.57222]→[3.57222:57332](∅→∅),[3.57222]→[3.57222:57332](∅→∅),[3.57222]→[3.57222:57332](∅→∅)

name = "case"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
replacement in Cargo.lock at line 139

[3.57344]→[3.32349:32368](∅→∅)

version = "1.0.35"

[3.57344]

[3.57363]

version = "1.0.59"
replacement in Cargo.lock at line 144

[3.57457]→[3.32369:32387](∅→∅)

version = "0.1.7"

[3.57457]

[3.57475]

version = "0.1.10"
replacement in Cargo.lock at line 149

[3.57569]→[3.57569:57587](∅→∅),[3.57569]→[3.57569:57587](∅→∅),[3.57569]→[3.57569:57587](∅→∅),[3.57569]→[3.57569:57587](∅→∅),[3.57569]→[3.57569:57587](∅→∅),[3.57569]→[3.57569:57587](∅→∅),[3.57569]→[3.57569:57587](∅→∅),[3.57569]→[3.57569:57587](∅→∅)

version = "0.4.6"

[3.57569]

[3.57587]

version = "0.4.15"
replacement in Cargo.lock at line 152

[3.57669]→[3.32388:32544](∅→∅),[3.32544]→[3.57259:57331](∅→∅),[3.38851]→[3.57259:57331](∅→∅),[3.57825]→[3.57259:57331](∅→∅)

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

[3.57669]

[3.57897]

"num-integer 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)",
"num-traits 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 159

[3.57926]→[3.38852:38871](∅→∅)

version = "2.33.0"

[3.57926]

[3.57945]

version = "2.33.3"
replacement in Cargo.lock at line 163

[3.58104]→[3.58104:58176](∅→∅),[3.58104]→[3.58104:58176](∅→∅),[3.58104]→[3.58104:58176](∅→∅),[3.58104]→[3.58104:58176](∅→∅),[3.58104]→[3.58104:58176](∅→∅),[3.58104]→[3.58104:58176](∅→∅),[3.58104]→[3.58104:58176](∅→∅),[3.58176]→[3.32545:32620](∅→∅)

"atty 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
"bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",

[3.58104]

[3.38947]

"atty 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
"bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 167

[3.57501]→[3.58400:58554](∅→∅),[3.49805]→[3.58400:58554](∅→∅),[3.49366]→[3.58400:58554](∅→∅),[3.70746]→[3.58400:58554](∅→∅),[3.39096]→[3.58400:58554](∅→∅),[3.48852]→[3.58400:58554](∅→∅),[3.58400]→[3.58400:58554](∅→∅)

"unicode-width 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"vec_map 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",

[3.39096]

[3.58554]

"unicode-width 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
"vec_map 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 176

[3.58687]→[3.32621:32696](∅→∅)

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

[3.58687]

[3.58762]

"bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 181

[3.58802]→[3.32697:32715](∅→∅)

version = "0.5.1"

[3.58802]

[3.58820]

version = "0.7.0"
replacement in Cargo.lock at line 184

[3.58902]→[3.32716:32874](∅→∅)

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

[3.58902]

[3.59060]

"core-foundation-sys 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 190

[3.59104]→[3.32875:32893](∅→∅),[3.57850]→[3.59638:59703](∅→∅),[3.50002]→[3.59638:59703](∅→∅),[3.49838]→[3.59638:59703](∅→∅),[3.71448]→[3.59638:59703](∅→∅),[3.32893]→[3.59638:59703](∅→∅),[3.44534]→[3.59638:59703](∅→∅),[3.39369]→[3.59638:59703](∅→∅),[3.59638]→[3.59638:59703](∅→∅),[3.59703]→[3.32894:32985](∅→∅),[3.50094]→[3.60184:60197](∅→∅),[3.32985]→[3.60184:60197](∅→∅),[3.60184]→[3.60184:60197](∅→∅),[3.60197]→[3.71525:71550](∅→∅),[3.71550]→[3.48999:49017](∅→∅)

version = "0.5.1"
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]]
name = "crossbeam-deque"
version = "0.7.1"

[3.59104]

[3.60240]

version = "0.7.0"
edit in Cargo.lock at line 192

[3.60305]→[3.58205:58222](∅→∅),[3.58222]→[3.71569:71651](∅→∅),[3.71651]→[3.58222:58306](∅→∅),[3.58222]→[3.58222:58306](∅→∅)

dependencies = [
"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)",
]
edit in Cargo.lock at line 194

[3.60419]→[3.71652:71853](∅→∅),[3.71853]→[3.32986:33059](∅→∅),[3.50168]→[3.71926:72008](∅→∅),[3.33059]→[3.71926:72008](∅→∅),[3.39443]→[3.71926:72008](∅→∅),[3.49091]→[3.71926:72008](∅→∅),[3.71926]→[3.71926:72008](∅→∅),[3.72008]→[3.49092:49170](∅→∅),[3.49170]→[3.72086:72254](∅→∅),[3.72086]→[3.72086:72254](∅→∅),[3.72254]→[3.49171:49393](∅→∅),[3.72254]→[3.58307:58350](∅→∅),[3.49393]→[3.58307:58350](∅→∅),[3.60419]→[3.58307:58350](∅→∅),[3.58350]→[3.60462:60544](∅→∅),[3.50230]→[3.60462:60544](∅→∅),[3.60462]→[3.60462:60544](∅→∅),[3.60544]→[3.33060:33133](∅→∅),[3.50242]→[3.49467:49545](∅→∅),[3.33133]→[3.49467:49545](∅→∅),[3.39517]→[3.49467:49545](∅→∅),[3.49467]→[3.49467:49545](∅→∅),[3.58502]→[3.60695:60710](∅→∅),[3.50394]→[3.60695:60710](∅→∅),[3.72406]→[3.60695:60710](∅→∅),[3.49545]→[3.60695:60710](∅→∅),[3.60695]→[3.60695:60710](∅→∅)

name = "crossbeam-epoch"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"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)",
"memoffset 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"scopeguard 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "crossbeam-queue"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "crossbeam-utils"
version = "0.6.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"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)",
]

[[package]]
replacement in Cargo.lock at line 198

[3.60830]→[3.58542:58623](∅→∅)

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

[3.60830]

[3.58623]

"generic-array 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 203

[3.60999]→[3.60999:61352](∅→∅),[3.60999]→[3.60999:61352](∅→∅),[3.60999]→[3.60999:61352](∅→∅)

name = "derive-error"
version = "0.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"case 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
"syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
replacement in Cargo.lock at line 204

[3.61368]→[3.58697:58715](∅→∅)

version = "0.8.0"

[3.61368]

[3.61386]

version = "0.8.1"
replacement in Cargo.lock at line 207

[3.61468]→[3.58716:58797](∅→∅)

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

[3.61468]

[3.61549]

"generic-array 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 211

[3.39630]→[3.61564:61585](∅→∅),[3.61564]→[3.61564:61585](∅→∅),[3.61585]→[3.49546:49565](∅→∅)

name = "encoding_rs"
version = "0.8.17"

[3.39630]

[3.61604]

name = "enum-as-inner"
version = "0.3.3"
replacement in Cargo.lock at line 215

[3.61686]→[3.33134:33207](∅→∅)

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

[3.61686]

[3.61759]

"heck 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
"proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
"syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 223

[3.61794]→[3.39705:39723](∅→∅)

version = "0.6.1"

[3.61794]

[3.61812]

version = "0.7.1"
replacement in Cargo.lock at line 226

[3.61894]→[3.61894:61966](∅→∅),[3.61894]→[3.61894:61966](∅→∅),[3.61894]→[3.61894:61966](∅→∅),[3.61894]→[3.61894:61966](∅→∅),[3.61894]→[3.61894:61966](∅→∅),[3.61894]→[3.61894:61966](∅→∅),[3.61894]→[3.61894:61966](∅→∅),[3.61966]→[3.58911:59057](∅→∅),[3.59057]→[3.33208:33356](∅→∅)

"atty 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
"humantime 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
"regex 1.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"termcolor 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",

[3.61894]

[3.62260]

"atty 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
"humantime 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
"regex 1.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
"termcolor 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 234

[3.62275]→[3.62275:62396](∅→∅),[3.62275]→[3.62275:62396](∅→∅),[3.62275]→[3.62275:62396](∅→∅),[3.62275]→[3.62275:62396](∅→∅),[3.62396]→[3.33357:33434](∅→∅),[3.59207]→[3.62473:62488](∅→∅),[3.50486]→[3.62473:62488](∅→∅),[3.51311]→[3.62473:62488](∅→∅),[3.72670]→[3.62473:62488](∅→∅),[3.33434]→[3.62473:62488](∅→∅),[3.39950]→[3.62473:62488](∅→∅),[3.49809]→[3.62473:62488](∅→∅),[3.62473]→[3.62473:62488](∅→∅)

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

[[package]]
replacement in Cargo.lock at line 235

[3.62505]→[3.59208:59226](∅→∅)

version = "0.1.5"

[3.62505]

[3.62523]

version = "0.1.8"
replacement in Cargo.lock at line 238

[3.62605]→[3.33435:33512](∅→∅),[3.50564]→[3.59304:59385](∅→∅),[3.72748]→[3.59304:59385](∅→∅),[3.33512]→[3.59304:59385](∅→∅),[3.40028]→[3.59304:59385](∅→∅),[3.49887]→[3.59304:59385](∅→∅),[3.59304]→[3.59304:59385](∅→∅)

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

[3.62605]

[3.62763]

"backtrace 0.3.50 (registry+https://github.com/rust-lang/crates.io-index)",
"failure_derive 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 244

[3.62802]→[3.59386:59404](∅→∅)

version = "0.1.5"

[3.62802]

[3.62820]

version = "0.1.8"
replacement in Cargo.lock at line 247

[3.62902]→[3.33513:33592](∅→∅),[3.33592]→[3.40108:40181](∅→∅),[3.40108]→[3.40108:40181](∅→∅),[3.40181]→[3.33593:33745](∅→∅)

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

[3.62902]

[3.63206]

"proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
"syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
"synstructure 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 260

[3.63349]→[3.63349:63367](∅→∅),[3.63349]→[3.63349:63367](∅→∅),[3.63349]→[3.63349:63367](∅→∅),[3.63349]→[3.63349:63367](∅→∅),[3.63349]→[3.63349:63367](∅→∅)

version = "1.0.6"

[3.63349]

[3.63367]

version = "1.0.7"
replacement in Cargo.lock at line 286

[3.64039]→[3.33746:33821](∅→∅)

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

[3.64039]

[3.64114]

"bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 301

[3.64522]→[3.50034:50122](∅→∅)

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

[3.64522]

[3.64610]

"new_debug_unreachable 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 306

[3.64642]→[3.33822:33841](∅→∅)

version = "0.1.26"

[3.64642]

[3.64661]

version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"futures-channel 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-executor 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-io 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-sink 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-task 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-util 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "futures-channel"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-sink 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "futures-core"
version = "0.3.5"
replacement in Cargo.lock at line 333

[3.64739]→[3.64739:64782](∅→∅),[3.64739]→[3.64739:64782](∅→∅),[3.64739]→[3.64739:64782](∅→∅),[3.64739]→[3.64739:64782](∅→∅),[3.64739]→[3.64739:64782](∅→∅),[3.64739]→[3.64739:64782](∅→∅),[3.64739]→[3.64739:64782](∅→∅),[3.64739]→[3.64739:64782](∅→∅)

name = "futures-cpupool"
version = "0.1.8"

[3.64739]

[3.64782]

name = "futures-executor"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-task 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-util 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
]

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

[[package]]
name = "futures-macro"
version = "0.3.5"
replacement in Cargo.lock at line 352

[3.64864]→[3.33842:33993](∅→∅)

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

[3.64864]

[3.65015]

"proc-macro-hack 0.5.18 (registry+https://github.com/rust-lang/crates.io-index)",
"proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
"syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
]

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

[[package]]
name = "futures-task"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"once_cell 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "futures-util"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"futures-channel 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-io 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-macro 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-sink 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-task 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
"pin-project 0.4.23 (registry+https://github.com/rust-lang/crates.io-index)",
"pin-utils 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"proc-macro-hack 0.5.18 (registry+https://github.com/rust-lang/crates.io-index)",
"proc-macro-nested 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
"slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 392

[3.65053]→[3.60091:60110](∅→∅)

version = "0.12.0"

[3.65053]

[3.65072]

version = "0.12.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"typenum 1.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "getrandom"
version = "0.1.14"
replacement in Cargo.lock at line 403

[3.65154]→[3.65154:65229](∅→∅),[3.65154]→[3.65154:65229](∅→∅),[3.65154]→[3.65154:65229](∅→∅)

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

[3.65154]

[3.65229]

"cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
"wasi 0.9.0+wasi-snapshot-preview1 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 409

[3.65244]

[3.65244]

name = "gimli"
version = "0.22.0"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
replacement in Cargo.lock at line 415

[3.65256]→[3.33994:34013](∅→∅)

version = "0.1.18"

[3.65256]

[3.65275]

version = "0.2.6"
replacement in Cargo.lock at line 418

[3.65357]→[3.34014:34090](∅→∅),[3.34090]→[3.40678:40751](∅→∅),[3.40678]→[3.40678:40751](∅→∅),[3.60280]→[3.65506:65576](∅→∅),[3.50979]→[3.65506:65576](∅→∅),[3.52260]→[3.65506:65576](∅→∅),[3.73248]→[3.65506:65576](∅→∅),[3.40751]→[3.65506:65576](∅→∅),[3.50388]→[3.65506:65576](∅→∅),[3.65506]→[3.65506:65576](∅→∅),[3.65576]→[3.34091:34166](∅→∅),[3.34166]→[3.40827:40899](∅→∅),[3.40827]→[3.40827:40899](∅→∅),[3.60428]→[3.65723:65798](∅→∅),[3.51127]→[3.65723:65798](∅→∅),[3.52408]→[3.65723:65798](∅→∅),[3.73396]→[3.65723:65798](∅→∅),[3.40899]→[3.65723:65798](∅→∅),[3.50536]→[3.65723:65798](∅→∅),[3.65723]→[3.65723:65798](∅→∅),[3.65798]→[3.60429:60499](∅→∅)

"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)",
"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)",
"http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
"indexmap 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.65357]

[3.60499]

"bytes 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
"fnv 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-sink 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-util 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"http 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"indexmap 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 426

[3.60570]→[3.34167:34240](∅→∅),[3.34240]→[3.50537:50613](∅→∅),[3.40973]→[3.50537:50613](∅→∅),[3.60643]→[3.50537:50613](∅→∅)

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

[3.60570]

[3.60719]

"tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-util 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
"tracing 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
]

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

[[package]]
name = "heck"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"unicode-segmentation 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "hermit-abi"
version = "0.1.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 454

[3.60748]→[3.60748:60766](∅→∅),[3.60748]→[3.60748:60766](∅→∅),[3.60748]→[3.60748:60766](∅→∅)

version = "0.7.0"

[3.60748]

[3.60766]

version = "0.7.1"
replacement in Cargo.lock at line 458

[3.60925]→[3.60925:60998](∅→∅),[3.60925]→[3.60925:60998](∅→∅),[3.60925]→[3.60925:60998](∅→∅)

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

[3.60925]

[3.66088]

"digest 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 463

[3.66400]→[3.66400:66418](∅→∅)

version = "0.1.5"

[3.66400]

[3.66418]

version = "0.3.1"
replacement in Cargo.lock at line 466

[3.66500]→[3.34241:34313](∅→∅),[3.61071]→[3.66572:66646](∅→∅),[3.51200]→[3.66572:66646](∅→∅),[3.52772]→[3.66572:66646](∅→∅),[3.73546]→[3.66572:66646](∅→∅),[3.34313]→[3.66572:66646](∅→∅),[3.44833]→[3.66572:66646](∅→∅),[3.41046]→[3.66572:66646](∅→∅),[3.50686]→[3.66572:66646](∅→∅),[3.66572]→[3.66572:66646](∅→∅)

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

[3.66500]

[3.66646]

"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
"match_cfg 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 473

[3.66675]→[3.41047:41066](∅→∅)

version = "0.1.17"

[3.66675]

[3.66694]

version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"bytes 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
"fnv 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
"itoa 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "http-body"
version = "0.3.1"
replacement in Cargo.lock at line 486

[3.66776]→[3.41067:41140](∅→∅),[3.61165]→[3.66849:66919](∅→∅),[3.51294]→[3.66849:66919](∅→∅),[3.52866]→[3.66849:66919](∅→∅),[3.73640]→[3.66849:66919](∅→∅),[3.41140]→[3.66849:66919](∅→∅),[3.50780]→[3.66849:66919](∅→∅),[3.66849]→[3.66849:66919](∅→∅),[3.66919]→[3.34314:34385](∅→∅)

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

[3.66776]

[3.41212]

"bytes 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
"http 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 492

[3.67023]→[3.67023:67041](∅→∅)

version = "1.3.3"

[3.67023]

[3.67041]

version = "1.3.4"
replacement in Cargo.lock at line 497

[3.67138]→[3.61166:61184](∅→∅)

version = "1.2.0"

[3.67138]

[3.67156]

version = "1.3.0"
replacement in Cargo.lock at line 500

[3.67238]→[3.67238:67316](∅→∅),[3.67238]→[3.67238:67316](∅→∅),[3.67238]→[3.67238:67316](∅→∅)

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

[3.67238]

[3.67316]

"quick-error 1.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 505

[3.67346]→[3.34386:34406](∅→∅)

version = "0.12.27"

[3.67346]

[3.67366]

version = "0.13.7"
replacement in Cargo.lock at line 508

[3.67448]→[3.41664:41737](∅→∅),[3.41737]→[3.34407:34482](∅→∅),[3.61354]→[3.67596:67678](∅→∅),[3.51464]→[3.67596:67678](∅→∅),[3.53055]→[3.67596:67678](∅→∅),[3.73810]→[3.67596:67678](∅→∅),[3.34482]→[3.67596:67678](∅→∅),[3.41812]→[3.67596:67678](∅→∅),[3.50950]→[3.67596:67678](∅→∅),[3.67596]→[3.67596:67678](∅→∅),[3.67678]→[3.34483:34553](∅→∅),[3.34553]→[3.41883:41955](∅→∅),[3.41883]→[3.41883:41955](∅→∅),[3.61497]→[3.67820:67967](∅→∅),[3.51607]→[3.67820:67967](∅→∅),[3.53198]→[3.67820:67967](∅→∅),[3.73953]→[3.67820:67967](∅→∅),[3.42031]→[3.67820:67967](∅→∅),[3.51093]→[3.67820:67967](∅→∅),[3.67820]→[3.67820:67967](∅→∅),[3.67967]→[3.34554:34625](∅→∅),[3.34625]→[3.61498:61568](∅→∅),[3.42103]→[3.61498:61568](∅→∅),[3.68038]→[3.61498:61568](∅→∅),[3.61568]→[3.68108:68180](∅→∅),[3.53269]→[3.68108:68180](∅→∅),[3.68108]→[3.68108:68180](∅→∅),[3.68180]→[3.51094:51174](∅→∅),[3.51174]→[3.61649:61721](∅→∅),[3.61649]→[3.61649:61721](∅→∅),[3.61721]→[3.34626:34699](∅→∅),[3.34699]→[3.42253:42334](∅→∅),[3.42253]→[3.42253:42334](∅→∅),[3.51762]→[3.51329:51485](∅→∅),[3.42334]→[3.51329:51485](∅→∅),[3.51329]→[3.51329:51485](∅→∅),[3.74264]→[3.62031:62107](∅→∅),[3.51485]→[3.62031:62107](∅→∅),[3.62031]→[3.62031:62107](∅→∅),[3.62107]→[3.34700:34863](∅→∅),[3.62270]→[3.68881:68952](∅→∅),[3.53889]→[3.68881:68952](∅→∅),[3.34863]→[3.68881:68952](∅→∅),[3.42498]→[3.68881:68952](∅→∅),[3.68881]→[3.68881:68952](∅→∅)

"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)",
"futures-cpupool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
"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)",
"httparse 1.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
"iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
"net2 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)",
"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)",
"want 0.0.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.67448]

[3.68952]

"bytes 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-channel 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-util 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"h2 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
"http 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"http-body 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
"httparse 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
"itoa 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
"pin-project 0.4.23 (registry+https://github.com/rust-lang/crates.io-index)",
"socket2 0.3.12 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
"tower-service 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"tracing 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
"want 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 528

[3.68981]→[3.68981:68999](∅→∅),[3.68981]→[3.68981:68999](∅→∅),[3.68981]→[3.68981:68999](∅→∅),[3.68981]→[3.68981:68999](∅→∅),[3.68981]→[3.68981:68999](∅→∅)

version = "0.1.5"

[3.68981]

[3.68999]

version = "0.2.0"
replacement in Cargo.lock at line 533

[3.69234]→[3.62271:62359](∅→∅)

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

[3.69234]

[3.69322]

"unicode-normalization 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 538

[3.69355]→[3.69355:69373](∅→∅),[3.69355]→[3.69355:69373](∅→∅),[3.69355]→[3.69355:69373](∅→∅)

version = "1.0.2"

[3.69355]

[3.69373]

version = "1.6.0"
edit in Cargo.lock at line 540

[3.69438]

[3.69438]

dependencies = [
"autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
"hashbrown 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 547

[3.69466]→[3.69466:69484](∅→∅),[3.69466]→[3.69466:69484](∅→∅),[3.69466]→[3.69466:69484](∅→∅)

version = "0.1.2"

[3.69466]

[3.69484]

version = "0.1.4"
replacement in Cargo.lock at line 550

[3.69566]→[3.34864:34936](∅→∅),[3.62432]→[3.69638:69711](∅→∅),[3.51920]→[3.69638:69711](∅→∅),[3.54051]→[3.69638:69711](∅→∅),[3.74422]→[3.69638:69711](∅→∅),[3.34936]→[3.69638:69711](∅→∅),[3.45065]→[3.69638:69711](∅→∅),[3.42571]→[3.69638:69711](∅→∅),[3.51643]→[3.69638:69711](∅→∅),[3.69638]→[3.69638:69711](∅→∅)

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

[3.69566]

[3.69711]

"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 555

[3.69744]→[3.62433:62451](∅→∅)

version = "0.1.9"

[3.69744]

[3.69762]

version = "0.2.2"
replacement in Cargo.lock at line 558

[3.69844]→[3.69844:69922](∅→∅),[3.69844]→[3.69844:69922](∅→∅),[3.69844]→[3.69844:69922](∅→∅),[3.69922]→[3.34937:35011](∅→∅),[3.35011]→[3.69996:70073](∅→∅),[3.42646]→[3.69996:70073](∅→∅),[3.69996]→[3.69996:70073](∅→∅),[3.70073]→[3.42647:42720](∅→∅),[3.62525]→[3.70146:70219](∅→∅),[3.51994]→[3.70146:70219](∅→∅),[3.54144]→[3.70146:70219](∅→∅),[3.74496]→[3.70146:70219](∅→∅),[3.42720]→[3.70146:70219](∅→∅),[3.51717]→[3.70146:70219](∅→∅),[3.70146]→[3.70146:70219](∅→∅)

"error-chain 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
"socket2 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
"widestring 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
"winreg 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",

[3.69844]

[3.70219]

"socket2 0.3.12 (registry+https://github.com/rust-lang/crates.io-index)",
"widestring 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
"winreg 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 566

[3.70248]→[3.35012:35030](∅→∅)

version = "0.4.3"

[3.70248]

[3.70266]

version = "0.4.6"
replacement in Cargo.lock at line 571

[3.70357]→[3.62526:62544](∅→∅)

version = "0.5.3"

[3.70357]

[3.70375]

version = "0.9.0"
replacement in Cargo.lock at line 574

[3.70457]→[3.62545:62775](∅→∅)

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

[3.70457]

[3.70687]

"minidom 0.12.0 (git+https://gitlab.com/xmpp-rs/xmpp-rs)",
replacement in Cargo.lock at line 593

[3.71124]→[3.51718:51736](∅→∅),[3.51736]→[3.35031:35145](∅→∅)

version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
name = "lazycell"
version = "1.2.1"

[3.71124]

[3.71142]

version = "1.4.0"
replacement in Cargo.lock at line 598

[3.71348]→[3.35146:35165](∅→∅)

version = "0.2.51"

[3.71348]

[3.71367]

version = "0.2.76"
replacement in Cargo.lock at line 603

[3.71470]→[3.42760:42778](∅→∅),[3.62852]→[3.71488:71584](∅→∅),[3.52033]→[3.71488:71584](∅→∅),[3.54570]→[3.71488:71584](∅→∅),[3.74554]→[3.71488:71584](∅→∅),[3.42778]→[3.71488:71584](∅→∅),[3.51775]→[3.71488:71584](∅→∅),[3.71488]→[3.71488:71584](∅→∅),[3.71584]→[3.62853:62871](∅→∅)

version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
name = "lock_api"
version = "0.1.5"

[3.71470]

[3.71602]

version = "0.5.3"
edit in Cargo.lock at line 605

[3.71667]→[3.71667:71684](∅→∅),[3.71667]→[3.71667:71684](∅→∅),[3.71667]→[3.71667:71684](∅→∅),[3.71684]→[3.62872:62949](∅→∅),[3.62949]→[3.71761:71838](∅→∅),[3.54667]→[3.71761:71838](∅→∅),[3.71761]→[3.71761:71838](∅→∅),[3.54757]→[3.54757:54759](∅→∅)

dependencies = [
"owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"scopeguard 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 608

[3.54785]→[3.62950:62968](∅→∅)

version = "0.4.6"

[3.54785]

[3.54803]

version = "0.4.11"
replacement in Cargo.lock at line 611

[3.54885]→[3.35166:35239](∅→∅)

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

[3.54885]

[3.72039]

"cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 619

[3.72173]→[3.42872:42954](∅→∅)

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

[3.72173]

[3.72255]

"linked-hash-map 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 629

[3.72400]→[3.63145:63163](∅→∅)

version = "0.7.5"

[3.72400]

[3.72418]

version = "0.10.0"
replacement in Cargo.lock at line 632

[3.72500]→[3.63164:63314](∅→∅),[3.63314]→[3.35240:35393](∅→∅),[3.52363]→[3.52105:52183](∅→∅),[3.35393]→[3.52105:52183](∅→∅),[3.43108]→[3.52105:52183](∅→∅),[3.52105]→[3.52105:52183](∅→∅),[3.63545]→[3.72881:73047](∅→∅),[3.55461]→[3.72881:73047](∅→∅),[3.74962]→[3.72881:73047](∅→∅),[3.52183]→[3.72881:73047](∅→∅),[3.72881]→[3.72881:73047](∅→∅)

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

[3.72500]

[3.63546]

"log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
"phf 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"phf_codegen 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.115 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_derive 1.0.115 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_json 1.0.57 (registry+https://github.com/rust-lang/crates.io-index)",
"string_cache 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"string_cache_codegen 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 644

[3.73136]

[3.73136]

name = "match_cfg"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
replacement in Cargo.lock at line 655

[3.73265]→[3.52184:52202](∅→∅)

version = "2.2.0"

[3.73265]

[3.73283]

version = "2.3.3"
replacement in Cargo.lock at line 659

[3.73361]→[3.73361:73463](∅→∅),[3.73361]→[3.73361:73463](∅→∅),[3.73361]→[3.73361:73463](∅→∅)

name = "memoffset"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"

[3.73361]

[3.73463]

name = "minidom"
version = "0.12.0"
source = "git+https://gitlab.com/xmpp-rs/xmpp-rs#b85aa293770d22cca11fd7ca3802b5920e1ab6fa"
dependencies = [
"quick-xml 0.18.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 667

[3.73476]→[3.73476:73493](∅→∅),[3.73476]→[3.73476:73493](∅→∅),[3.73476]→[3.73476:73493](∅→∅),[3.73493]→[3.63640:63659](∅→∅)

name = "minidom"
version = "0.10.0"

[3.73476]

[3.73512]

name = "miniz_oxide"
version = "0.4.1"
replacement in Cargo.lock at line 671

[3.73594]→[3.63660:63815](∅→∅),[3.63815]→[3.52203:52280](∅→∅)

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

[3.73594]

[3.73826]

"adler 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 676

[3.73854]→[3.35394:35413](∅→∅)

version = "0.6.16"

[3.73854]

[3.73873]

version = "0.6.22"
edit in Cargo.lock at line 679

[3.73955]

[3.73955]

"cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 682

[3.74121]→[3.74121:74193](∅→∅),[3.74121]→[3.74121:74193](∅→∅),[3.74121]→[3.74121:74193](∅→∅)

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

[3.74121]

[3.74193]

"iovec 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 684

[3.74272]→[3.35414:35561](∅→∅),[3.52436]→[3.64040:64110](∅→∅),[3.75297]→[3.64040:64110](∅→∅),[3.35561]→[3.64040:64110](∅→∅),[3.45158]→[3.64040:64110](∅→∅),[3.43201]→[3.64040:64110](∅→∅),[3.52353]→[3.64040:64110](∅→∅),[3.64040]→[3.64040:64110](∅→∅)

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

[3.74272]

[3.74489]

"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 687

[3.74560]→[3.74560:74632](∅→∅),[3.74560]→[3.74560:74632](∅→∅),[3.74560]→[3.74560:74632](∅→∅)

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

[3.74560]

[3.64111]

"net2 0.2.35 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 694

[3.74808]→[3.74808:74826](∅→∅),[3.74808]→[3.74808:74826](∅→∅),[3.74808]→[3.74808:74826](∅→∅)

version = "0.6.7"

[3.74808]

[3.74826]

version = "0.6.8"
replacement in Cargo.lock at line 697

[3.74908]→[3.74908:74980](∅→∅),[3.74908]→[3.74908:74980](∅→∅),[3.74908]→[3.74908:74980](∅→∅),[3.74980]→[3.35562:35705](∅→∅)

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

[3.74908]

[3.75123]

"iovec 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
"mio 0.6.22 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 708

[3.75331]→[3.75331:75403](∅→∅),[3.75331]→[3.75331:75403](∅→∅),[3.75331]→[3.75331:75403](∅→∅)

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

[3.75331]

[3.75403]

"net2 0.2.35 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 715

[3.75588]→[3.35706:35724](∅→∅)

version = "0.2.2"

[3.75588]

[3.75606]

version = "0.2.4"
replacement in Cargo.lock at line 718

[3.75688]→[3.52427:52505](∅→∅),[3.52505]→[3.35725:35797](∅→∅),[3.52601]→[3.64406:64476](∅→∅),[3.75521]→[3.64406:64476](∅→∅),[3.35797]→[3.64406:64476](∅→∅),[3.45323]→[3.64406:64476](∅→∅),[3.43437]→[3.64406:64476](∅→∅),[3.52577]→[3.64406:64476](∅→∅),[3.64406]→[3.64406:64476](∅→∅),[3.64476]→[3.35798:35874](∅→∅)

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

[3.75688]

[3.75984]

"lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
"openssl 0.10.30 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 723

[3.76064]→[3.35875:35954](∅→∅),[3.52758]→[3.52734:52810](∅→∅),[3.35954]→[3.52734:52810](∅→∅),[3.43594]→[3.52734:52810](∅→∅),[3.52734]→[3.52734:52810](∅→∅),[3.52810]→[3.35955:36204](∅→∅)

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

[3.76064]

[3.76468]

"openssl-sys 0.9.58 (registry+https://github.com/rust-lang/crates.io-index)",
"schannel 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)",
"security-framework 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)",
"security-framework-sys 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
"tempfile 3.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 732

[3.76497]→[3.76497:76516](∅→∅),[3.76497]→[3.76497:76516](∅→∅),[3.76497]→[3.76497:76516](∅→∅),[3.76497]→[3.76497:76516](∅→∅),[3.76497]→[3.76497:76516](∅→∅),[3.76497]→[3.76497:76516](∅→∅),[3.76497]→[3.76497:76516](∅→∅)

version = "0.2.33"

[3.76497]

[3.76516]

version = "0.2.35"
replacement in Cargo.lock at line 735

[3.76598]→[3.36205:36350](∅→∅),[3.36350]→[3.43990:44063](∅→∅),[3.43990]→[3.43990:44063](∅→∅)

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

[3.76598]

[3.76816]

"cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 742

[3.76862]→[3.53106:53124](∅→∅)

version = "1.0.3"

[3.76862]

[3.76880]

version = "1.0.4"
edit in Cargo.lock at line 746

[3.76958]→[3.76958:76974](∅→∅),[3.76958]→[3.76958:76974](∅→∅),[3.76958]→[3.76958:76974](∅→∅),[3.76974]→[3.65196:65215](∅→∅),[3.65215]→[3.76993:77071](∅→∅),[3.57473]→[3.76993:77071](∅→∅),[3.76993]→[3.76993:77071](∅→∅)

name = "nodrop"
version = "0.1.13"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
replacement in Cargo.lock at line 747

[3.77092]→[3.36351:36370](∅→∅)

version = "0.1.39"

[3.77092]

[3.77111]

version = "0.1.43"
replacement in Cargo.lock at line 750

[3.77193]→[3.36371:36448](∅→∅)

"num-traits 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.77193]

[3.77270]

"autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
"num-traits 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 756

[3.77305]→[3.36449:36467](∅→∅)

version = "0.2.6"

[3.77305]

[3.77323]

version = "0.2.12"
edit in Cargo.lock at line 758

[3.77388]

[3.77388]

dependencies = [
"autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 764

[3.77419]→[3.36468:36487](∅→∅)

version = "1.10.0"

[3.77419]

[3.77438]

version = "1.13.0"
replacement in Cargo.lock at line 767

[3.77520]→[3.36488:36560](∅→∅)

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

[3.77520]

[3.77592]

"hermit-abi 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 772

[3.44455]

[3.65322]

name = "object"
version = "0.20.0"
source = "registry+https://github.com/rust-lang/crates.io-index"

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

[[package]]
replacement in Cargo.lock at line 783

[3.65344]→[3.65344:65362](∅→∅),[3.65344]→[3.65344:65362](∅→∅)

version = "0.2.2"

[3.65344]

[3.65362]

version = "0.2.3"
replacement in Cargo.lock at line 788

[3.77742]→[3.36561:36581](∅→∅)

version = "0.10.20"

[3.77742]

[3.77762]

version = "0.10.30"
replacement in Cargo.lock at line 791

[3.77844]→[3.36582:36730](∅→∅)

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

[3.77844]

[3.77992]

"bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 794

[3.78072]→[3.53313:53391](∅→∅),[3.53391]→[3.36731:36882](∅→∅)

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

[3.78072]

[3.78301]

"lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
"openssl-sys 0.9.58 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 806

[3.78456]→[3.36883:36902](∅→∅)

version = "0.9.43"

[3.78456]

[3.78475]

version = "0.9.58"
replacement in Cargo.lock at line 809

[3.78557]→[3.36903:37045](∅→∅),[3.65915]→[3.78699:78777](∅→∅),[3.53635]→[3.78699:78777](∅→∅),[3.58053]→[3.78699:78777](∅→∅),[3.76746]→[3.78699:78777](∅→∅),[3.37045]→[3.78699:78777](∅→∅),[3.45903]→[3.78699:78777](∅→∅),[3.45113]→[3.78699:78777](∅→∅),[3.53705]→[3.78699:78777](∅→∅),[3.78699]→[3.78699:78777](∅→∅),[3.78777]→[3.37046:37126](∅→∅),[3.65996]→[3.78857:78929](∅→∅),[3.37126]→[3.78857:78929](∅→∅),[3.53786]→[3.78857:78929](∅→∅),[3.78857]→[3.78857:78929](∅→∅)

"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)",
"pkg-config 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
"rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
"vcpkg 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",

[3.78557]

[3.78929]

"autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
"cc 1.0.59 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
"pkg-config 0.3.18 (registry+https://github.com/rust-lang/crates.io-index)",
"vcpkg 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 817

[3.78944]→[3.78944:78964](∅→∅),[3.78944]→[3.78944:78964](∅→∅),[3.78944]→[3.78944:78964](∅→∅),[3.78944]→[3.78944:78964](∅→∅),[3.78964]→[3.65997:66015](∅→∅)

name = "owning_ref"
version = "0.4.0"

[3.78944]

[3.78982]

name = "pbkdf2"
version = "0.3.0"
replacement in Cargo.lock at line 821

[3.79064]→[3.79064:79149](∅→∅),[3.79064]→[3.79064:79149](∅→∅),[3.79064]→[3.79064:79149](∅→∅)

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

[3.79064]

[3.79149]

"byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
"crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 826

[3.79164]→[3.79164:79185](∅→∅),[3.79164]→[3.79164:79185](∅→∅),[3.79164]→[3.79164:79185](∅→∅),[3.79185]→[3.66016:66034](∅→∅)

name = "parking_lot"
version = "0.7.1"

[3.79164]

[3.79203]

name = "percent-encoding"
version = "2.1.0"
edit in Cargo.lock at line 829

[3.79268]→[3.79268:79285](∅→∅),[3.79268]→[3.79268:79285](∅→∅),[3.79268]→[3.79268:79285](∅→∅),[3.79285]→[3.66035:66193](∅→∅),[3.66193]→[3.79443:79445](∅→∅),[3.58250]→[3.79443:79445](∅→∅),[3.79443]→[3.79443:79445](∅→∅)

dependencies = [
"lock_api 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"parking_lot_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 831

[3.79458]→[3.79458:79484](∅→∅),[3.79458]→[3.79458:79484](∅→∅),[3.79458]→[3.79458:79484](∅→∅),[3.79484]→[3.66194:66212](∅→∅)

name = "parking_lot_core"
version = "0.4.0"

[3.79458]

[3.79502]

name = "phf"
version = "0.8.0"
replacement in Cargo.lock at line 835

[3.79584]→[3.37127:37199](∅→∅),[3.53708]→[3.66285:66356](∅→∅),[3.76819]→[3.66285:66356](∅→∅),[3.37199]→[3.66285:66356](∅→∅),[3.45976]→[3.66285:66356](∅→∅),[3.45186]→[3.66285:66356](∅→∅),[3.53859]→[3.66285:66356](∅→∅),[3.66285]→[3.66285:66356](∅→∅),[3.66356]→[3.79727:79807](∅→∅),[3.58413]→[3.79727:79807](∅→∅),[3.79727]→[3.79727:79807](∅→∅),[3.79807]→[3.37200:37275](∅→∅),[3.37275]→[3.45263:45336](∅→∅),[3.45263]→[3.45263:45336](∅→∅)

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

[3.79584]

[3.66505]

"phf_shared 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 839

[3.66520]→[3.66520:66554](∅→∅),[3.66520]→[3.66520:66554](∅→∅),[3.66520]→[3.66520:66554](∅→∅),[3.66520]→[3.66520:66554](∅→∅),[3.66520]→[3.66520:66554](∅→∅)

name = "pbkdf2"
version = "0.3.0"

[3.66520]

[3.66554]

name = "phf_codegen"
version = "0.8.0"
replacement in Cargo.lock at line 843

[3.66636]→[3.37276:37352](∅→∅),[3.37352]→[3.66712:66789](∅→∅),[3.45413]→[3.66712:66789](∅→∅),[3.66712]→[3.66712:66789](∅→∅)

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

[3.66636]

[3.80239]

"phf_generator 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"phf_shared 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 848

[3.80254]→[3.80254:80298](∅→∅),[3.80254]→[3.80254:80298](∅→∅),[3.80254]→[3.80254:80298](∅→∅)

name = "percent-encoding"
version = "1.0.1"

[3.80254]

[3.80298]

name = "phf_generator"
version = "0.8.0"
edit in Cargo.lock at line 851

[3.80363]

[3.80363]

dependencies = [
"phf_shared 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 857

[3.80376]→[3.80376:80389](∅→∅),[3.80376]→[3.80376:80389](∅→∅),[3.80376]→[3.80376:80389](∅→∅),[3.80389]→[3.66790:66809](∅→∅)

name = "phf"
version = "0.7.24"

[3.80376]

[3.80408]

name = "phf_shared"
version = "0.8.0"
replacement in Cargo.lock at line 861

[3.80490]→[3.66810:66888](∅→∅)

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

[3.80490]

[3.80568]

"siphasher 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 865

[3.80583]→[3.80583:80604](∅→∅),[3.80583]→[3.80583:80604](∅→∅),[3.80583]→[3.80583:80604](∅→∅),[3.80604]→[3.66889:66908](∅→∅)

name = "phf_codegen"
version = "0.7.24"

[3.80583]

[3.80623]

name = "pin-project"
version = "0.4.23"
replacement in Cargo.lock at line 869

[3.80705]→[3.66909:67068](∅→∅)

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

[3.80705]

[3.80864]

"pin-project-internal 0.4.23 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 873

[3.80879]→[3.80879:80902](∅→∅),[3.80879]→[3.80879:80902](∅→∅),[3.80879]→[3.80879:80902](∅→∅),[3.80902]→[3.67069:67088](∅→∅)

name = "phf_generator"
version = "0.7.24"

[3.80879]

[3.80921]

name = "pin-project-internal"
version = "0.4.23"
replacement in Cargo.lock at line 877

[3.81003]→[3.67089:67238](∅→∅)

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

[3.81003]

[3.81152]

"proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
"syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 883

[3.81167]→[3.81167:81187](∅→∅),[3.81167]→[3.81167:81187](∅→∅),[3.81167]→[3.81167:81187](∅→∅),[3.81187]→[3.67239:67258](∅→∅)

name = "phf_shared"
version = "0.7.24"

[3.81167]

[3.81206]

name = "pin-project-lite"
version = "0.1.7"
replacement in Cargo.lock at line 886

[3.81271]→[3.81271:81366](∅→∅),[3.81271]→[3.81271:81366](∅→∅),[3.81271]→[3.81271:81366](∅→∅)

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

[3.81271]

[3.81366]

[[package]]
name = "pin-utils"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
replacement in Cargo.lock at line 894

[3.81399]→[3.81399:81418](∅→∅),[3.81399]→[3.81399:81418](∅→∅),[3.81399]→[3.81399:81418](∅→∅)

version = "0.3.14"

[3.81399]

[3.81418]

version = "0.3.18"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
name = "ppv-lite86"
version = "0.2.9"
replacement in Cargo.lock at line 908

[3.81618]→[3.81618:81639](∅→∅),[3.81618]→[3.81618:81639](∅→∅),[3.81618]→[3.81618:81639](∅→∅),[3.81639]→[3.37353:37372](∅→∅)

name = "proc-macro2"
version = "0.4.27"

[3.81618]

[3.81658]

name = "proc-macro-hack"
version = "0.5.18"
edit in Cargo.lock at line 911

[3.81723]→[3.81723:81820](∅→∅),[3.81723]→[3.81723:81820](∅→∅),[3.81723]→[3.81723:81820](∅→∅),[3.81723]→[3.81723:81820](∅→∅),[3.81723]→[3.81723:81820](∅→∅),[3.81723]→[3.81723:81820](∅→∅),[3.81723]→[3.81723:81820](∅→∅)

dependencies = [
"unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 913

[3.81833]→[3.81833:81872](∅→∅),[3.81833]→[3.81833:81872](∅→∅),[3.81833]→[3.81833:81872](∅→∅),[3.81833]→[3.81833:81872](∅→∅),[3.81833]→[3.81833:81872](∅→∅),[3.81833]→[3.81833:81872](∅→∅),[3.81833]→[3.81833:81872](∅→∅)

name = "quick-error"
version = "1.2.2"

[3.81833]

[3.81872]

name = "proc-macro-nested"
version = "0.1.6"
replacement in Cargo.lock at line 918

[3.81950]→[3.81950:81969](∅→∅),[3.81950]→[3.81950:81969](∅→∅),[3.81950]→[3.81950:81969](∅→∅),[3.81950]→[3.81950:81969](∅→∅),[3.81950]→[3.81950:81969](∅→∅),[3.81950]→[3.81950:81969](∅→∅),[3.81950]→[3.81950:81969](∅→∅),[3.81969]→[3.54009:54028](∅→∅)

name = "quick-xml"
version = "0.13.3"

[3.81950]

[3.81988]

name = "proc-macro2"
version = "1.0.20"
replacement in Cargo.lock at line 922

[3.82070]→[3.54029:54108](∅→∅),[3.77068]→[3.67378:67522](∅→∅),[3.54108]→[3.67378:67522](∅→∅),[3.67378]→[3.67378:67522](∅→∅),[3.67522]→[3.54109:54182](∅→∅)

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

[3.82070]

[3.82366]

"unicode-xid 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 926

[3.82381]→[3.82381:82415](∅→∅),[3.82381]→[3.82381:82415](∅→∅),[3.82381]→[3.82381:82415](∅→∅),[3.82381]→[3.82381:82415](∅→∅),[3.82381]→[3.82381:82415](∅→∅)

name = "quote"
version = "0.3.15"

[3.82381]

[3.82415]

name = "quick-error"
version = "1.2.3"
replacement in Cargo.lock at line 931

[3.82493]→[3.82493:82508](∅→∅),[3.82493]→[3.82493:82508](∅→∅),[3.82493]→[3.82493:82508](∅→∅),[3.82493]→[3.82493:82508](∅→∅),[3.82493]→[3.82493:82508](∅→∅),[3.82508]→[3.45434:45453](∅→∅)

name = "quote"
version = "0.6.12"

[3.82493]

[3.82527]

name = "quick-xml"
version = "0.18.1"
replacement in Cargo.lock at line 935

[3.82609]→[3.37373:37452](∅→∅)

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

[3.82609]

[3.82688]

"memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 939

[3.82703]→[3.82703:82717](∅→∅),[3.82703]→[3.82703:82717](∅→∅),[3.82703]→[3.82703:82717](∅→∅),[3.82703]→[3.82703:82717](∅→∅),[3.82703]→[3.82703:82717](∅→∅),[3.82703]→[3.82703:82717](∅→∅),[3.82703]→[3.82703:82717](∅→∅),[3.82717]→[3.67696:67714](∅→∅)

name = "rand"
version = "0.5.6"

[3.82703]

[3.82735]

name = "quote"
version = "1.0.7"
replacement in Cargo.lock at line 943

[3.82817]→[3.67715:67870](∅→∅),[3.67870]→[3.37453:37525](∅→∅),[3.53975]→[3.67942:68018](∅→∅),[3.77235]→[3.67942:68018](∅→∅),[3.37525]→[3.67942:68018](∅→∅),[3.46149]→[3.67942:68018](∅→∅),[3.45606]→[3.67942:68018](∅→∅),[3.54275]→[3.67942:68018](∅→∅),[3.67942]→[3.67942:68018](∅→∅),[3.68018]→[3.45607:45680](∅→∅)

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

[3.82817]

[3.83193]

"proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 948

[3.83222]→[3.68092:68110](∅→∅)

version = "0.6.5"

[3.83222]

[3.68110]

version = "0.7.3"
replacement in Cargo.lock at line 951

[3.68192]→[3.37526:37672](∅→∅),[3.54122]→[3.68338:68643](∅→∅),[3.77382]→[3.68338:68643](∅→∅),[3.37672]→[3.68338:68643](∅→∅),[3.46222]→[3.68338:68643](∅→∅),[3.45827]→[3.68338:68643](∅→∅),[3.54422]→[3.68338:68643](∅→∅),[3.68338]→[3.68338:68643](∅→∅),[3.68643]→[3.37673:37751](∅→∅),[3.37751]→[3.45906:45980](∅→∅),[3.45906]→[3.45906:45980](∅→∅),[3.54197]→[3.54497:54572](∅→∅),[3.45980]→[3.54497:54572](∅→∅),[3.54497]→[3.54497:54572](∅→∅),[3.77532]→[3.68870:68950](∅→∅),[3.54572]→[3.68870:68950](∅→∅),[3.68870]→[3.68870:68950](∅→∅),[3.68950]→[3.45981:46054](∅→∅)

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

[3.68192]

[3.69023]

"getrandom 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_chacha 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_core 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_hc 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_pcg 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 961

[3.69059]→[3.69059:69077](∅→∅),[3.69059]→[3.69059:69077](∅→∅),[3.69059]→[3.69059:69077](∅→∅),[3.69059]→[3.69059:69077](∅→∅),[3.69059]→[3.69059:69077](∅→∅)

version = "0.1.1"

[3.69059]

[3.83240]

version = "0.2.2"
replacement in Cargo.lock at line 964

[3.83322]→[3.37752:37826](∅→∅),[3.37826]→[3.69152:69228](∅→∅),[3.46129]→[3.69152:69228](∅→∅),[3.69152]→[3.69152:69228](∅→∅)

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

[3.83322]

[3.84153]

"ppv-lite86 0.2.9 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_core 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 973

[3.84573]→[3.69248:69324](∅→∅)

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

[3.84573]

[3.84649]

"rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 978

[3.84683]→[3.69325:69343](∅→∅)

version = "0.4.0"

[3.84683]

[3.69343]

version = "0.4.2"
replacement in Cargo.lock at line 982

[3.69421]→[3.69421:69456](∅→∅)

name = "rand_hc"
version = "0.1.0"

[3.69421]

[3.69456]

name = "rand_core"
version = "0.5.1"
replacement in Cargo.lock at line 986

[3.69538]→[3.69538:69614](∅→∅)

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

[3.69538]

[3.69614]

"getrandom 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 990

[3.69629]→[3.69629:69667](∅→∅)

name = "rand_isaac"
version = "0.1.1"

[3.69629]

[3.69667]

name = "rand_hc"
version = "0.2.0"
replacement in Cargo.lock at line 994

[3.69749]→[3.69749:69825](∅→∅)

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

[3.69749]

[3.69825]

"rand_core 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 998

[3.69840]→[3.69840:69861](∅→∅),[3.69861]→[3.37827:37845](∅→∅),[3.37845]→[3.69879:69961](∅→∅),[3.46148]→[3.69879:69961](∅→∅),[3.69879]→[3.69879:69961](∅→∅),[3.69961]→[3.37846:37918](∅→∅),[3.54344]→[3.70033:70109](∅→∅),[3.77679]→[3.70033:70109](∅→∅),[3.37918]→[3.70033:70109](∅→∅),[3.46295]→[3.70033:70109](∅→∅),[3.46221]→[3.70033:70109](∅→∅),[3.54719]→[3.70033:70109](∅→∅),[3.70033]→[3.70033:70109](∅→∅),[3.70109]→[3.46222:46295](∅→∅),[3.54418]→[3.70182:70197](∅→∅),[3.77753]→[3.70182:70197](∅→∅),[3.46295]→[3.70182:70197](∅→∅),[3.54793]→[3.70182:70197](∅→∅),[3.70182]→[3.70182:70197](∅→∅)

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]]
replacement in Cargo.lock at line 1004

[3.70469]→[3.37919:37991](∅→∅),[3.54510]→[3.70541:70617](∅→∅),[3.77845]→[3.70541:70617](∅→∅),[3.37991]→[3.70541:70617](∅→∅),[3.46368]→[3.70541:70617](∅→∅),[3.46387]→[3.70541:70617](∅→∅),[3.54885]→[3.70541:70617](∅→∅),[3.70541]→[3.70541:70617](∅→∅)

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

[3.70469]

[3.70617]

"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1007

[3.70690]→[3.46388:46461](∅→∅)

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

[3.70690]

[3.70763]

"winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1012

[3.70796]→[3.54960:54978](∅→∅)

version = "0.1.2"

[3.70796]

[3.70814]

version = "0.2.1"
replacement in Cargo.lock at line 1015

[3.70896]→[3.37992:38066](∅→∅),[3.38066]→[3.55053:55129](∅→∅),[3.46536]→[3.55053:55129](∅→∅),[3.55053]→[3.55053:55129](∅→∅)

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

[3.70896]

[3.71046]

"rand_core 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 1019

[3.71061]→[3.71061:71275](∅→∅),[3.71061]→[3.71061:71275](∅→∅),[3.71061]→[3.71061:71275](∅→∅)

name = "rand_xorshift"
version = "0.1.1"
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 1028

[3.86863]→[3.46537:46556](∅→∅),[3.71425]→[3.86882:87001](∅→∅),[3.54604]→[3.86882:87001](∅→∅),[3.60245]→[3.86882:87001](∅→∅),[3.78115]→[3.86882:87001](∅→∅),[3.46556]→[3.86882:87001](∅→∅),[3.55149]→[3.86882:87001](∅→∅),[3.86882]→[3.86882:87001](∅→∅)

version = "0.1.54"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
name = "redox_termios"
version = "0.1.1"

[3.86863]

[3.87001]

version = "0.1.57"
edit in Cargo.lock at line 1030

[3.87066]→[3.87066:87083](∅→∅),[3.87066]→[3.87066:87083](∅→∅),[3.87066]→[3.87066:87083](∅→∅),[3.87066]→[3.87066:87083](∅→∅),[3.87066]→[3.87066:87083](∅→∅),[3.87066]→[3.87066:87083](∅→∅),[3.87066]→[3.87066:87083](∅→∅),[3.87083]→[3.46557:46638](∅→∅),[3.71507]→[3.87164:87166](∅→∅),[3.54686]→[3.87164:87166](∅→∅),[3.60327]→[3.87164:87166](∅→∅),[3.78197]→[3.87164:87166](∅→∅),[3.46638]→[3.87164:87166](∅→∅),[3.55231]→[3.87164:87166](∅→∅),[3.87164]→[3.87164:87166](∅→∅)

dependencies = [
"redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 1033

[3.87194]→[3.38067:38085](∅→∅)

version = "1.1.5"

[3.87194]

[3.87212]

version = "1.3.9"
replacement in Cargo.lock at line 1036

[3.87294]→[3.46658:46737](∅→∅),[3.54786]→[3.55330:55403](∅→∅),[3.46737]→[3.55330:55403](∅→∅),[3.55330]→[3.55330:55403](∅→∅),[3.55403]→[3.38086:38165](∅→∅),[3.71758]→[3.87525:87604](∅→∅),[3.54866]→[3.87525:87604](∅→∅),[3.60578]→[3.87525:87604](∅→∅),[3.78448]→[3.87525:87604](∅→∅),[3.38165]→[3.87525:87604](∅→∅),[3.46817]→[3.87525:87604](∅→∅),[3.55482]→[3.87525:87604](∅→∅),[3.87525]→[3.87525:87604](∅→∅),[3.87604]→[3.38166:38244](∅→∅)

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

[3.87294]

[3.87682]

"aho-corasick 0.7.13 (registry+https://github.com/rust-lang/crates.io-index)",
"memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
"regex-syntax 0.6.18 (registry+https://github.com/rust-lang/crates.io-index)",
"thread_local 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1044

[3.87719]→[3.38245:38263](∅→∅)

version = "0.6.6"

[3.87719]

[3.87737]

version = "0.6.18"
edit in Cargo.lock at line 1046

[3.87802]→[3.87802:87819](∅→∅),[3.87802]→[3.87802:87819](∅→∅),[3.87802]→[3.87802:87819](∅→∅),[3.87802]→[3.87802:87819](∅→∅),[3.87802]→[3.87802:87819](∅→∅),[3.87802]→[3.87802:87819](∅→∅),[3.87802]→[3.87802:87819](∅→∅),[3.87802]→[3.87802:87819](∅→∅),[3.87819]→[3.71857:71932](∅→∅),[3.71932]→[3.87894:87896](∅→∅),[3.60752]→[3.87894:87896](∅→∅),[3.87894]→[3.87894:87896](∅→∅)

dependencies = [
"ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 1049

[3.87933]→[3.38264:38282](∅→∅)

version = "0.5.1"

[3.87933]

[3.87951]

version = "0.5.3"
replacement in Cargo.lock at line 1052

[3.88033]→[3.46935:47008](∅→∅)

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

[3.88033]

[3.88106]

"winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1057

[3.88142]→[3.72007:72025](∅→∅)

version = "0.6.2"

[3.88142]

[3.88160]

version = "0.6.3"
replacement in Cargo.lock at line 1060

[3.88242]→[3.88242:88395](∅→∅),[3.88242]→[3.88242:88395](∅→∅),[3.88242]→[3.88242:88395](∅→∅)

"hostname 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"quick-error 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)",

[3.88242]

[3.88395]

"hostname 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
"quick-error 1.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1066

[3.88434]→[3.38283:38302](∅→∅)

version = "0.1.14"

[3.88434]

[3.88453]

version = "0.1.16"
edit in Cargo.lock at line 1070

[3.88531]→[3.88531:88742](∅→∅),[3.88531]→[3.88531:88742](∅→∅),[3.88531]→[3.88531:88742](∅→∅),[3.88531]→[3.88531:88742](∅→∅),[3.88531]→[3.88531:88742](∅→∅),[3.88531]→[3.88531:88742](∅→∅),[3.88531]→[3.88531:88742](∅→∅),[3.88531]→[3.88531:88742](∅→∅)

name = "rustc_version"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
replacement in Cargo.lock at line 1071

[3.88755]→[3.38303:38321](∅→∅)

version = "0.2.7"

[3.88755]

[3.88773]

version = "1.0.5"
replacement in Cargo.lock at line 1080

[3.72158]→[3.72158:72229](∅→∅)

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

[3.72158]

[3.72229]

"hmac 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1083

[3.55054]→[3.72376:72519](∅→∅),[3.78636]→[3.72376:72519](∅→∅),[3.47122]→[3.72376:72519](∅→∅),[3.55670]→[3.72376:72519](∅→∅),[3.72376]→[3.72376:72519](∅→∅)

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

[3.47122]

[3.89400]

"sha-1 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
"sha2 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1089

[3.89433]→[3.55671:55690](∅→∅)

version = "0.1.15"

[3.89433]

[3.89452]

version = "0.1.19"
replacement in Cargo.lock at line 1092

[3.89534]→[3.55691:55769](∅→∅),[3.55769]→[3.47123:47196](∅→∅)

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

[3.89534]

[3.89685]

"lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 1095

[3.89687]→[3.89687:89803](∅→∅),[3.89687]→[3.89687:89803](∅→∅),[3.89687]→[3.89687:89803](∅→∅),[3.89687]→[3.89687:89803](∅→∅),[3.89687]→[3.89687:89803](∅→∅),[3.89687]→[3.89687:89803](∅→∅),[3.89687]→[3.89687:89803](∅→∅)

[[package]]
name = "scopeguard"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
replacement in Cargo.lock at line 1098

[3.89844]→[3.38322:38340](∅→∅)

version = "0.2.2"

[3.89844]

[3.89862]

version = "0.4.4"
replacement in Cargo.lock at line 1101

[3.89944]→[3.38341:38670](∅→∅)

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

[3.89944]

[3.90273]

"bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"core-foundation 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
"core-foundation-sys 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
"security-framework-sys 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1110

[3.90320]→[3.38671:38689](∅→∅)

version = "0.2.3"

[3.90320]

[3.90338]

version = "0.4.3"
replacement in Cargo.lock at line 1113

[3.90420]→[3.38690:38927](∅→∅)

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

[3.90420]

[3.90657]

"core-foundation-sys 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 1118

[3.90672]→[3.90672:90871](∅→∅),[3.90672]→[3.90672:90871](∅→∅),[3.90672]→[3.90672:90871](∅→∅),[3.90672]→[3.90672:90871](∅→∅),[3.90672]→[3.90672:90871](∅→∅),[3.90672]→[3.90672:90871](∅→∅),[3.90672]→[3.90672:90871](∅→∅),[3.90672]→[3.90672:90871](∅→∅),[3.90672]→[3.90672:90871](∅→∅),[3.90871]→[3.42276:42288](∅→∅),[3.42276]→[3.42276:42288](∅→∅),[3.42288]→[3.90872:90991](∅→∅)

name = "semver"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
]

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

[[package]]
replacement in Cargo.lock at line 1121

[3.91027]→[3.47652:47801](∅→∅),[3.55884]→[3.73194:73268](∅→∅),[3.79104]→[3.73194:73268](∅→∅),[3.47801]→[3.73194:73268](∅→∅),[3.56138]→[3.73194:73268](∅→∅),[3.73194]→[3.73194:73268](∅→∅),[3.73268]→[3.38928:39002](∅→∅),[3.55959]→[3.73420:73565](∅→∅),[3.79179]→[3.73420:73565](∅→∅),[3.39002]→[3.73420:73565](∅→∅),[3.47954]→[3.73420:73565](∅→∅),[3.56291]→[3.73420:73565](∅→∅),[3.73420]→[3.73420:73565](∅→∅),[3.73565]→[3.39003:39229](∅→∅),[3.73791]→[3.91695:91775](∅→∅),[3.56186]→[3.91695:91775](∅→∅),[3.62205]→[3.91695:91775](∅→∅),[3.79406]→[3.91695:91775](∅→∅),[3.39229]→[3.91695:91775](∅→∅),[3.46916]→[3.91695:91775](∅→∅),[3.48181]→[3.91695:91775](∅→∅),[3.56518]→[3.91695:91775](∅→∅),[3.91695]→[3.91695:91775](∅→∅),[3.91775]→[3.73792:73948](∅→∅),[3.73948]→[3.39230:39301](∅→∅),[3.39301]→[3.48253:48333](∅→∅),[3.48253]→[3.48253:48333](∅→∅)

"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)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
"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)",
"tokio-channel 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-signal 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
"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)",

[3.91027]

[3.92082]

"clap 2.33.3 (registry+https://github.com/rust-lang/crates.io-index)",
"env_logger 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
"failure 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-util 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"hyper 0.13.7 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
"minidom 0.12.0 (git+https://gitlab.com/xmpp-rs/xmpp-rs)",
"pin-project 0.4.23 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.115 (registry+https://github.com/rust-lang/crates.io-index)",
"serde_derive 1.0.115 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-xmpp 2.0.0 (git+https://gitlab.com/xmpp-rs/xmpp-rs)",
"toml 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
"xmpp-parsers 0.17.0 (git+https://gitlab.com/xmpp-rs/xmpp-rs)",
replacement in Cargo.lock at line 1140

[3.92112]→[3.39302:39321](∅→∅)

version = "1.0.90"

[3.92112]

[3.92131]

version = "1.0.115"
replacement in Cargo.lock at line 1145

[3.92231]→[3.39322:39341](∅→∅)

version = "1.0.90"

[3.92231]

[3.92250]

version = "1.0.115"
replacement in Cargo.lock at line 1148

[3.92332]→[3.39342:39421](∅→∅),[3.39421]→[3.48453:48526](∅→∅),[3.48453]→[3.48453:48526](∅→∅),[3.48526]→[3.39422:39494](∅→∅)

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

[3.92332]

[3.92556]

"proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
"syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1155

[3.92591]→[3.56857:56876](∅→∅)

version = "1.0.39"

[3.92591]

[3.92610]

version = "1.0.57"
replacement in Cargo.lock at line 1158

[3.92692]→[3.39495:39709](∅→∅)

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

[3.92692]

[3.92906]

"itoa 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
"ryu 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
"serde 1.0.115 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1165

[3.92936]→[3.74529:74547](∅→∅)

version = "0.8.1"

[3.92936]

[3.92954]

version = "0.8.2"
replacement in Cargo.lock at line 1168

[3.93036]→[3.39710:39789](∅→∅),[3.56833]→[3.74627:74700](∅→∅),[3.79994]→[3.74627:74700](∅→∅),[3.39789]→[3.74627:74700](∅→∅),[3.47149]→[3.74627:74700](∅→∅),[3.48893]→[3.74627:74700](∅→∅),[3.57030]→[3.74627:74700](∅→∅),[3.74627]→[3.74627:74700](∅→∅)

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

[3.93036]

[3.93188]

"block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
"digest 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1171

[3.93264]→[3.74701:74780](∅→∅)

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

[3.93264]

[3.93343]

"opaque-debug 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1176

[3.93372]→[3.74781:74799](∅→∅)

version = "0.8.0"

[3.93372]

[3.93390]

version = "0.8.2"
replacement in Cargo.lock at line 1179

[3.93472]→[3.39790:39869](∅→∅),[3.56913]→[3.74879:74952](∅→∅),[3.80074]→[3.74879:74952](∅→∅),[3.39869]→[3.74879:74952](∅→∅),[3.47229]→[3.74879:74952](∅→∅),[3.48973]→[3.74879:74952](∅→∅),[3.57110]→[3.74879:74952](∅→∅),[3.74879]→[3.74879:74952](∅→∅)

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

[3.93472]

[3.93624]

"block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
"digest 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1182

[3.93700]→[3.74953:75032](∅→∅)

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

[3.93700]

[3.93779]

"opaque-debug 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1187

[3.93808]→[3.39870:39888](∅→∅)

version = "0.8.1"

[3.93808]

[3.93826]

version = "0.8.2"
replacement in Cargo.lock at line 1190

[3.93908]→[3.39889:39968](∅→∅)

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

[3.93908]

[3.75131]

"block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1192

[3.75208]→[3.75208:75281](∅→∅),[3.75208]→[3.75208:75281](∅→∅),[3.75208]→[3.75208:75281](∅→∅),[3.75208]→[3.75208:75281](∅→∅),[3.75208]→[3.75208:75281](∅→∅),[3.75208]→[3.75208:75281](∅→∅),[3.75208]→[3.75208:75281](∅→∅)

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

[3.75208]

[3.94137]

"digest 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1194

[3.94210]→[3.75282:75361](∅→∅)

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

[3.94210]

[3.94289]

"opaque-debug 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1198

[3.94304]→[3.94304:94325](∅→∅),[3.94304]→[3.94304:94325](∅→∅),[3.94325]→[3.39969:39987](∅→∅)

name = "signal-hook"
version = "0.1.8"

[3.94304]

[3.49091]

name = "signal-hook-registry"
version = "1.2.1"
replacement in Cargo.lock at line 1202

[3.49173]→[3.39988:40136](∅→∅)

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

[3.49173]

[3.49332]

"arc-swap 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1208

[3.94607]→[3.94607:94625](∅→∅)

version = "0.2.3"

[3.94607]

[3.94625]

version = "0.3.3"
replacement in Cargo.lock at line 1218

[3.94831]→[3.40137:40155](∅→∅)

version = "0.6.9"

[3.94831]

[3.94849]

version = "1.4.2"
replacement in Cargo.lock at line 1223

[3.94944]→[3.40156:40174](∅→∅)

version = "0.3.8"

[3.94944]

[3.94962]

version = "0.3.12"
replacement in Cargo.lock at line 1226

[3.95044]→[3.40175:40320](∅→∅),[3.40320]→[3.49729:49883](∅→∅),[3.49729]→[3.49729:49883](∅→∅)

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

[3.95044]

[3.95343]

"cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
"redox_syscall 0.1.57 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 1231

[3.95345]→[3.95345:95498](∅→∅),[3.95345]→[3.95345:95498](∅→∅),[3.95345]→[3.95345:95498](∅→∅),[3.95345]→[3.95345:95498](∅→∅),[3.95345]→[3.95345:95498](∅→∅),[3.95345]→[3.95345:95498](∅→∅),[3.95345]→[3.95345:95498](∅→∅),[3.95498]→[3.40321:40339](∅→∅),[3.75886]→[3.95516:95581](∅→∅),[3.64310]→[3.95516:95581](∅→∅),[3.40339]→[3.95516:95581](∅→∅),[3.49902]→[3.95516:95581](∅→∅),[3.95516]→[3.95516:95581](∅→∅)

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

[[package]]
name = "string"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
replacement in Cargo.lock at line 1234

[3.95616]→[3.95616:95634](∅→∅),[3.95616]→[3.95616:95634](∅→∅)

version = "0.7.3"

[3.95616]

[3.95634]

version = "0.8.0"
replacement in Cargo.lock at line 1237

[3.95716]→[3.57678:57844](∅→∅),[3.80905]→[3.76053:76131](∅→∅),[3.57844]→[3.76053:76131](∅→∅),[3.76053]→[3.76053:76131](∅→∅)

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

[3.95716]

[3.95960]

"lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"new_debug_unreachable 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
"phf_shared 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1241

[3.96043]→[3.40340:40413](∅→∅),[3.76205]→[3.96116:96289](∅→∅),[3.57553]→[3.96116:96289](∅→∅),[3.64629]→[3.96116:96289](∅→∅),[3.80979]→[3.96116:96289](∅→∅),[3.40413]→[3.96116:96289](∅→∅),[3.50069]→[3.96116:96289](∅→∅),[3.57918]→[3.96116:96289](∅→∅),[3.96116]→[3.96116:96289](∅→∅)

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

[3.96043]

[3.96289]

"serde 1.0.115 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1246

[3.96334]→[3.96334:96352](∅→∅),[3.96334]→[3.96334:96352](∅→∅),[3.96334]→[3.96334:96352](∅→∅),[3.96334]→[3.96334:96352](∅→∅),[3.96334]→[3.96334:96352](∅→∅),[3.96334]→[3.96334:96352](∅→∅),[3.96334]→[3.96334:96352](∅→∅),[3.96334]→[3.96334:96352](∅→∅)

version = "0.4.2"

[3.96334]

[3.96352]

version = "0.5.1"
replacement in Cargo.lock at line 1249

[3.96434]→[3.76206:76365](∅→∅),[3.76365]→[3.40414:40493](∅→∅),[3.40493]→[3.50149:50222](∅→∅),[3.50149]→[3.50149:50222](∅→∅),[3.76517]→[3.96745:96831](∅→∅),[3.57706]→[3.96745:96831](∅→∅),[3.64940]→[3.96745:96831](∅→∅),[3.81053]→[3.96745:96831](∅→∅),[3.50222]→[3.96745:96831](∅→∅),[3.57992]→[3.96745:96831](∅→∅),[3.96745]→[3.96745:96831](∅→∅)

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

[3.96434]

[3.96831]

"phf_generator 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"phf_shared 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
"proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 1256

[3.96846]→[3.96846:96971](∅→∅),[3.96846]→[3.96846:96971](∅→∅),[3.96846]→[3.96846:96971](∅→∅),[3.96846]→[3.96846:96971](∅→∅),[3.96846]→[3.96846:96971](∅→∅),[3.96846]→[3.96846:96971](∅→∅),[3.96846]→[3.96846:96971](∅→∅)

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

[[package]]
edit in Cargo.lock at line 1263

[3.76648]→[3.97005:97083](∅→∅),[3.64959]→[3.97005:97083](∅→∅),[3.97005]→[3.97005:97083](∅→∅),[3.97195]→[3.97195:97228](∅→∅)

source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
name = "syn"
version = "0.11.11"
edit in Cargo.lock at line 1264

[3.97293]→[3.97293:97536](∅→∅)

dependencies = [
"quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
"synom 0.11.3 (registry+https://github.com/rust-lang/crates.io-index)",
"unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 1267

[3.97562]→[3.40494:40514](∅→∅),[3.76669]→[3.97582:97664](∅→∅),[3.57746]→[3.97582:97664](∅→∅),[3.64980]→[3.97582:97664](∅→∅),[3.34791]→[3.97582:97664](∅→∅),[3.81093]→[3.97582:97664](∅→∅),[3.40514]→[3.97582:97664](∅→∅),[3.47974]→[3.97582:97664](∅→∅),[3.50262]→[3.97582:97664](∅→∅),[3.58032]→[3.97582:97664](∅→∅),[3.97582]→[3.97582:97664](∅→∅),[3.97664]→[3.40515:40594](∅→∅),[3.40594]→[3.50342:50415](∅→∅),[3.50342]→[3.50342:50415](∅→∅),[3.76822]→[3.97816:97943](∅→∅),[3.57899]→[3.97816:97943](∅→∅),[3.65132]→[3.97816:97943](∅→∅),[3.81167]→[3.97816:97943](∅→∅),[3.50415]→[3.97816:97943](∅→∅),[3.58106]→[3.97816:97943](∅→∅),[3.97816]→[3.97816:97943](∅→∅)

version = "0.15.30"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"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)",
"unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "synom"
version = "0.11.3"

[3.97562]

[3.97943]

version = "1.0.40"
replacement in Cargo.lock at line 1270

[3.98025]→[3.98025:98103](∅→∅),[3.98025]→[3.98025:98103](∅→∅),[3.98025]→[3.98025:98103](∅→∅),[3.98025]→[3.98025:98103](∅→∅),[3.98025]→[3.98025:98103](∅→∅),[3.98025]→[3.98025:98103](∅→∅),[3.98025]→[3.98025:98103](∅→∅)

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

[3.98025]

[3.98103]

"proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
"unicode-xid 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1277

[3.98140]→[3.40595:40614](∅→∅)

version = "0.10.1"

[3.98140]

[3.98159]

version = "0.12.4"
replacement in Cargo.lock at line 1280

[3.98241]→[3.40615:40694](∅→∅),[3.40694]→[3.50515:50588](∅→∅),[3.50515]→[3.50515:50588](∅→∅),[3.50588]→[3.40695:40767](∅→∅),[3.77067]→[3.98465:98543](∅→∅),[3.58124]→[3.98465:98543](∅→∅),[3.65376]→[3.98465:98543](∅→∅),[3.34864]→[3.98465:98543](∅→∅),[3.81313]→[3.98465:98543](∅→∅),[3.40767]→[3.98465:98543](∅→∅),[3.48207]→[3.98465:98543](∅→∅),[3.50660]→[3.98465:98543](∅→∅),[3.58252]→[3.98465:98543](∅→∅),[3.98465]→[3.98465:98543](∅→∅)

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

[3.98241]

[3.98543]

"proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
"syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
"unicode-xid 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1288

[3.98576]→[3.40768:40786](∅→∅)

version = "3.0.7"

[3.98576]

[3.98594]

version = "3.1.0"
replacement in Cargo.lock at line 1291

[3.98676]→[3.40787:40932](∅→∅),[3.58270]→[3.77232:77303](∅→∅),[3.81478]→[3.77232:77303](∅→∅),[3.40932]→[3.77232:77303](∅→∅),[3.48280]→[3.77232:77303](∅→∅),[3.50825]→[3.77232:77303](∅→∅),[3.58417]→[3.77232:77303](∅→∅),[3.77232]→[3.77232:77303](∅→∅),[3.77303]→[3.50826:50907](∅→∅),[3.50907]→[3.40933:41014](∅→∅),[3.41014]→[3.50988:51061](∅→∅),[3.50988]→[3.50988:51061](∅→∅)

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

[3.98676]

[3.99127]

"cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
"redox_syscall 0.1.57 (registry+https://github.com/rust-lang/crates.io-index)",
"remove_dir_all 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1311

[3.99506]→[3.41015:41033](∅→∅)

version = "1.0.4"

[3.99506]

[3.99524]

version = "1.1.0"
replacement in Cargo.lock at line 1314

[3.99606]→[3.99606:99681](∅→∅),[3.99606]→[3.99606:99681](∅→∅),[3.99606]→[3.99606:99681](∅→∅)

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

[3.99606]

[3.99681]

"winapi-util 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 1318

[3.99696]→[3.99696:99713](∅→∅),[3.99696]→[3.99696:99713](∅→∅),[3.99696]→[3.99696:99713](∅→∅),[3.99713]→[3.41034:41052](∅→∅),[3.58445]→[3.99731:99813](∅→∅),[3.41052]→[3.99731:99813](∅→∅),[3.48299]→[3.99731:99813](∅→∅),[3.51099]→[3.99731:99813](∅→∅),[3.99731]→[3.99731:99813](∅→∅),[3.99813]→[3.41053:41125](∅→∅),[3.41125]→[3.51245:51326](∅→∅),[3.51245]→[3.51245:51326](∅→∅),[3.77704]→[3.99966:100061](∅→∅),[3.58599]→[3.99966:100061](∅→∅),[3.66013]→[3.99966:100061](∅→∅),[3.81788]→[3.99966:100061](∅→∅),[3.51326]→[3.99966:100061](∅→∅),[3.58727]→[3.99966:100061](∅→∅),[3.99966]→[3.99966:100061](∅→∅)

name = "termion"
version = "1.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"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)",
"redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
edit in Cargo.lock at line 1320

[3.77724]→[3.100098:100397](∅→∅),[3.58619]→[3.100098:100397](∅→∅),[3.66033]→[3.100098:100397](∅→∅),[3.81808]→[3.100098:100397](∅→∅),[3.51346]→[3.100098:100397](∅→∅),[3.58747]→[3.100098:100397](∅→∅),[3.100098]→[3.100098:100397](∅→∅),[3.100397]→[3.58748:58826](∅→∅),[3.77803]→[3.100475:100504](∅→∅),[3.66112]→[3.100475:100504](∅→∅),[3.81887]→[3.100475:100504](∅→∅),[3.58826]→[3.100475:100504](∅→∅),[3.100475]→[3.100475:100504](∅→∅),[3.100504]→[3.77804:77823](∅→∅),[3.77823]→[3.100523:100605](∅→∅),[3.66132]→[3.100523:100605](∅→∅),[3.100523]→[3.100523:100605](∅→∅),[3.100605]→[3.41126:41198](∅→∅),[3.41198]→[3.51419:51573](∅→∅),[3.51419]→[3.51419:51573](∅→∅),[3.78050]→[3.100831:100861](∅→∅),[3.58846]→[3.100831:100861](∅→∅),[3.66359]→[3.100831:100861](∅→∅),[3.82114]→[3.100831:100861](∅→∅),[3.51573]→[3.100831:100861](∅→∅),[3.59053]→[3.100831:100861](∅→∅),[3.100831]→[3.100831:100861](∅→∅),[3.100861]→[3.41199:41218](∅→∅)

source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"unicode-width 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "thread_local"
version = "0.3.6"
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)",
]

[[package]]
name = "time"
version = "0.1.42"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"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)",
]

[[package]]
name = "tokio"
version = "0.1.18"
replacement in Cargo.lock at line 1322

[3.100962]→[3.51594:51667](∅→∅),[3.51667]→[3.41219:41441](∅→∅),[3.78296]→[3.101257:101335](∅→∅),[3.82359]→[3.101257:101335](∅→∅),[3.41441]→[3.101257:101335](∅→∅),[3.51889]→[3.101257:101335](∅→∅),[3.59299]→[3.101257:101335](∅→∅),[3.101257]→[3.101257:101335](∅→∅),[3.101335]→[3.51890:52058](∅→∅),[3.59184]→[3.59468:59699](∅→∅),[3.52058]→[3.59468:59699](∅→∅),[3.59468]→[3.59468:59699](∅→∅),[3.59699]→[3.41442:41519](∅→∅),[3.59262]→[3.78773:78849](∅→∅),[3.82836]→[3.78773:78849](∅→∅),[3.41519]→[3.78773:78849](∅→∅),[3.48616]→[3.78773:78849](∅→∅),[3.52136]→[3.78773:78849](∅→∅),[3.59776]→[3.78773:78849](∅→∅),[3.78773]→[3.78773:78849](∅→∅),[3.78849]→[3.41520:41766](∅→∅),[3.41766]→[3.79095:79247](∅→∅),[3.52383]→[3.79095:79247](∅→∅),[3.59945]→[3.79095:79247](∅→∅),[3.79095]→[3.79095:79247](∅→∅)

"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)",
"mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
"num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"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)",
"tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-uds 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",

[3.100962]

[3.102285]

"unicode-width 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1326

[3.102300]→[3.102300:102341](∅→∅),[3.102300]→[3.102300:102341](∅→∅),[3.102300]→[3.102300:102341](∅→∅),[3.102300]→[3.102300:102341](∅→∅)

name = "tokio-channel"
version = "0.1.0"

[3.102300]

[3.102341]

name = "thiserror"
version = "1.0.20"
replacement in Cargo.lock at line 1330

[3.102423]→[3.41767:41842](∅→∅)

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

[3.102423]

[3.102498]

"thiserror-impl 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1334

[3.102513]→[3.102513:102634](∅→∅),[3.102513]→[3.102513:102634](∅→∅),[3.102513]→[3.102513:102634](∅→∅),[3.102513]→[3.102513:102634](∅→∅),[3.102513]→[3.102513:102634](∅→∅),[3.102513]→[3.102513:102634](∅→∅),[3.102513]→[3.102513:102634](∅→∅),[3.102513]→[3.102513:102634](∅→∅),[3.102634]→[3.52816:52889](∅→∅),[3.52889]→[3.41843:41918](∅→∅),[3.59572]→[3.60170:60246](∅→∅),[3.41918]→[3.60170:60246](∅→∅),[3.52964]→[3.60170:60246](∅→∅),[3.60170]→[3.60170:60246](∅→∅),[3.79548]→[3.102858:102903](∅→∅),[3.67618]→[3.102858:102903](∅→∅),[3.83222]→[3.102858:102903](∅→∅),[3.60246]→[3.102858:102903](∅→∅),[3.102858]→[3.102858:102903](∅→∅),[3.102903]→[3.52965:52983](∅→∅)

name = "tokio-codec"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"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)",
]

[[package]]
name = "tokio-current-thread"
version = "0.1.6"

[3.102513]

[3.102921]

name = "thiserror-impl"
version = "1.0.20"
replacement in Cargo.lock at line 1338

[3.103003]→[3.41919:41994](∅→∅),[3.41994]→[3.53059:53140](∅→∅),[3.53059]→[3.53059:53140](∅→∅)

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

[3.103003]

[3.103159]

"proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
"syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1344

[3.103174]→[3.103174:103198](∅→∅),[3.103174]→[3.103174:103198](∅→∅),[3.103174]→[3.103174:103198](∅→∅),[3.103174]→[3.103174:103198](∅→∅),[3.103174]→[3.103174:103198](∅→∅),[3.103174]→[3.103174:103198](∅→∅),[3.103174]→[3.103174:103198](∅→∅),[3.103198]→[3.53141:53159](∅→∅)

name = "tokio-executor"
version = "0.1.7"

[3.103174]

[3.103216]

name = "thread_local"
version = "1.0.1"
replacement in Cargo.lock at line 1348

[3.103298]→[3.79744:79826](∅→∅),[3.79826]→[3.41995:42070](∅→∅)

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

[3.103298]

[3.103455]

"lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1352

[3.103470]→[3.103470:103488](∅→∅),[3.103470]→[3.103470:103488](∅→∅),[3.103470]→[3.103470:103488](∅→∅),[3.103470]→[3.103470:103488](∅→∅),[3.103470]→[3.103470:103488](∅→∅),[3.103470]→[3.103470:103488](∅→∅),[3.103470]→[3.103470:103488](∅→∅),[3.103470]→[3.103470:103488](∅→∅),[3.103488]→[3.60518:60536](∅→∅)

name = "tokio-fs"
version = "0.1.6"

[3.103470]

[3.103506]

name = "time"
version = "0.1.44"
replacement in Cargo.lock at line 1356

[3.103588]→[3.42071:42146](∅→∅),[3.59919]→[3.60612:60688](∅→∅),[3.42146]→[3.60612:60688](∅→∅),[3.53311]→[3.60612:60688](∅→∅),[3.60612]→[3.60612:60688](∅→∅),[3.60688]→[3.42147:42231](∅→∅)

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

[3.103588]

[3.103823]

"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
"wasi 0.10.0+wasi-snapshot-preview1 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1362

[3.103838]→[3.103838:103856](∅→∅),[3.103838]→[3.103838:103856](∅→∅),[3.103838]→[3.103838:103856](∅→∅),[3.103838]→[3.103838:103856](∅→∅),[3.103838]→[3.103838:103856](∅→∅),[3.103838]→[3.103838:103856](∅→∅),[3.103838]→[3.103838:103856](∅→∅),[3.103838]→[3.103838:103856](∅→∅),[3.103838]→[3.103838:103856](∅→∅),[3.103856]→[3.60773:60792](∅→∅)

name = "tokio-io"
version = "0.1.12"

[3.103838]

[3.103875]

name = "tinyvec"
version = "0.3.4"
edit in Cargo.lock at line 1365

[3.103940]→[3.103940:103957](∅→∅),[3.103940]→[3.103940:103957](∅→∅),[3.103940]→[3.103940:103957](∅→∅),[3.103940]→[3.103940:103957](∅→∅),[3.103940]→[3.103940:103957](∅→∅),[3.103957]→[3.53397:53470](∅→∅),[3.53470]→[3.42232:42307](∅→∅),[3.60153]→[3.80325:80395](∅→∅),[3.83917]→[3.80325:80395](∅→∅),[3.42307]→[3.80325:80395](∅→∅),[3.53545]→[3.80325:80395](∅→∅),[3.60941]→[3.80325:80395](∅→∅),[3.80325]→[3.80325:80395](∅→∅),[3.80395]→[3.104175:104177](∅→∅),[3.68382]→[3.104175:104177](∅→∅),[3.104175]→[3.104175:104177](∅→∅)

dependencies = [
"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)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
replacement in Cargo.lock at line 1367

[3.104190]→[3.104190:104213](∅→∅),[3.104190]→[3.104190:104213](∅→∅),[3.104190]→[3.104190:104213](∅→∅),[3.104213]→[3.60942:60960](∅→∅)

name = "tokio-reactor"
version = "0.1.9"

[3.104190]

[3.104231]

name = "tokio"
version = "0.2.22"
replacement in Cargo.lock at line 1371

[3.104313]→[3.80415:80497](∅→∅),[3.80497]→[3.42308:42383](∅→∅),[3.60229]→[3.61036:61114](∅→∅),[3.42383]→[3.61036:61114](∅→∅),[3.53621]→[3.61036:61114](∅→∅),[3.61036]→[3.61036:61114](∅→∅),[3.84090]→[3.80650:80720](∅→∅),[3.61114]→[3.80650:80720](∅→∅),[3.80650]→[3.80650:80720](∅→∅),[3.80720]→[3.42384:42531](∅→∅),[3.84166]→[3.80797:80875](∅→∅),[3.42531]→[3.80797:80875](∅→∅),[3.53769]→[3.80797:80875](∅→∅),[3.61191]→[3.80797:80875](∅→∅),[3.80797]→[3.80797:80875](∅→∅)

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

[3.104313]

[3.80875]

"bytes 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
"fnv 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"iovec 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)",
"memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
"mio 0.6.22 (registry+https://github.com/rust-lang/crates.io-index)",
"mio-uds 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)",
"num_cpus 1.13.0 (registry+https://github.com/rust-lang/crates.io-index)",
"pin-project-lite 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"signal-hook-registry 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1384

[3.80946]→[3.53770:53851](∅→∅),[3.60311]→[3.61273:61349](∅→∅),[3.53851]→[3.61273:61349](∅→∅),[3.61273]→[3.61273:61349](∅→∅),[3.61349]→[3.42532:42609](∅→∅),[3.81180]→[3.105148:105185](∅→∅),[3.60389]→[3.105148:105185](∅→∅),[3.69089]→[3.105148:105185](∅→∅),[3.84324]→[3.105148:105185](∅→∅),[3.42609]→[3.105148:105185](∅→∅),[3.48864]→[3.105148:105185](∅→∅),[3.53929]→[3.105148:105185](∅→∅),[3.61426]→[3.105148:105185](∅→∅),[3.105148]→[3.105148:105185](∅→∅),[3.105185]→[3.81181:81199](∅→∅),[3.81199]→[3.105203:105285](∅→∅),[3.69108]→[3.105203:105285](∅→∅),[3.105203]→[3.105203:105285](∅→∅),[3.105285]→[3.42610:42828](∅→∅),[3.42828]→[3.105503:105577](∅→∅),[3.54148]→[3.105503:105577](∅→∅),[3.105503]→[3.105503:105577](∅→∅),[3.105577]→[3.42829:42907](∅→∅),[3.42907]→[3.54227:54308](∅→∅),[3.54227]→[3.54227:54308](∅→∅),[3.60697]→[3.61734:61890](∅→∅),[3.54308]→[3.61734:61890](∅→∅),[3.61734]→[3.61734:61890](∅→∅),[3.61890]→[3.54309:54382](∅→∅),[3.60771]→[3.81736:81771](∅→∅),[3.84861]→[3.81736:81771](∅→∅),[3.54382]→[3.81736:81771](∅→∅),[3.61963]→[3.81736:81771](∅→∅),[3.81736]→[3.81736:81771](∅→∅),[3.81771]→[3.42908:42926](∅→∅),[3.60790]→[3.81789:81871](∅→∅),[3.84880]→[3.81789:81871](∅→∅),[3.42926]→[3.81789:81871](∅→∅),[3.49035]→[3.81789:81871](∅→∅),[3.54401]→[3.81789:81871](∅→∅),[3.61982]→[3.81789:81871](∅→∅),[3.81789]→[3.81789:81871](∅→∅),[3.81871]→[3.61983:62053](∅→∅),[3.62053]→[3.42927:43002](∅→∅)

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

[[package]]
name = "tokio-signal"
version = "0.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"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)",
"mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
"mio-uds 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
"signal-hook 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-executor 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-reactor 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
name = "tokio-sync"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",

[3.80946]

[3.105965]

"tokio-macros 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
"winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1389

[3.106260]→[3.106260:106279](∅→∅),[3.106279]→[3.82017:82035](∅→∅)

name = "tokio-tcp"
version = "0.1.3"

[3.105980]

[3.106297]

name = "tokio-macros"
version = "0.2.5"
replacement in Cargo.lock at line 1393

[3.106379]→[3.54478:54551](∅→∅),[3.54551]→[3.43003:43078](∅→∅),[3.82184]→[3.106527:106599](∅→∅),[3.61015]→[3.106527:106599](∅→∅),[3.69813]→[3.106527:106599](∅→∅),[3.85105]→[3.106527:106599](∅→∅),[3.43078]→[3.106527:106599](∅→∅),[3.54626]→[3.106527:106599](∅→∅),[3.62277]→[3.106527:106599](∅→∅),[3.106527]→[3.106527:106599](∅→∅),[3.106599]→[3.43079:43150](∅→∅),[3.43150]→[3.62278:62434](∅→∅),[3.54698]→[3.62278:62434](∅→∅),[3.106670]→[3.62278:62434](∅→∅)

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

[3.106379]

[3.106826]

"proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)",
"syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1399

[3.106841]→[3.106841:106867](∅→∅),[3.106841]→[3.106841:106867](∅→∅),[3.106841]→[3.106841:106867](∅→∅),[3.106841]→[3.106841:106867](∅→∅),[3.106841]→[3.106841:106867](∅→∅),[3.106867]→[3.43151:43170](∅→∅)

name = "tokio-threadpool"
version = "0.1.13"

[3.106841]

[3.106886]

name = "tokio-tls"
version = "0.3.1"
replacement in Cargo.lock at line 1403

[3.106968]→[3.62455:62619](∅→∅),[3.85525]→[3.82526:82608](∅→∅),[3.62619]→[3.82526:82608](∅→∅),[3.82526]→[3.82526:82608](∅→∅),[3.82608]→[3.43171:43246](∅→∅),[3.61111]→[3.82683:82753](∅→∅),[3.85601]→[3.82683:82753](∅→∅),[3.43246]→[3.82683:82753](∅→∅),[3.54794]→[3.82683:82753](∅→∅),[3.62695]→[3.82683:82753](∅→∅),[3.82683]→[3.82683:82753](∅→∅),[3.82753]→[3.43247:43323](∅→∅),[3.85677]→[3.82829:82971](∅→∅),[3.43323]→[3.82829:82971](∅→∅),[3.54871]→[3.82829:82971](∅→∅),[3.62772]→[3.82829:82971](∅→∅),[3.82829]→[3.82829:82971](∅→∅),[3.82971]→[3.54872:54953](∅→∅)

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

[3.106968]

[3.107658]

"native-tls 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1408

[3.107673]→[3.107673:107694](∅→∅),[3.107673]→[3.107673:107694](∅→∅),[3.107673]→[3.107673:107694](∅→∅),[3.107673]→[3.107673:107694](∅→∅),[3.107673]→[3.107673:107694](∅→∅),[3.107673]→[3.107673:107694](∅→∅),[3.107673]→[3.107673:107694](∅→∅),[3.107694]→[3.43324:43343](∅→∅)

name = "tokio-timer"
version = "0.2.10"

[3.107673]

[3.107713]

name = "tokio-util"
version = "0.2.0"
replacement in Cargo.lock at line 1412

[3.107795]→[3.83073:83155](∅→∅),[3.83155]→[3.43344:43419](∅→∅),[3.61269]→[3.83230:83301](∅→∅),[3.85835]→[3.83230:83301](∅→∅),[3.43419]→[3.83230:83301](∅→∅),[3.55049]→[3.83230:83301](∅→∅),[3.62930]→[3.83230:83301](∅→∅),[3.83230]→[3.83230:83301](∅→∅),[3.83301]→[3.55050:55131](∅→∅)

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

[3.107795]

[3.108104]

"bytes 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-sink 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
"pin-project-lite 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1421

[3.108119]→[3.108119:108138](∅→∅),[3.108119]→[3.108119:108138](∅→∅),[3.108119]→[3.108119:108138](∅→∅),[3.108119]→[3.108119:108138](∅→∅),[3.108119]→[3.108119:108138](∅→∅),[3.108119]→[3.108119:108138](∅→∅),[3.108119]→[3.108119:108138](∅→∅),[3.108138]→[3.83383:83401](∅→∅)

name = "tokio-tls"
version = "0.2.1"

[3.108119]

[3.108156]

name = "tokio-util"
version = "0.3.1"
replacement in Cargo.lock at line 1425

[3.108238]→[3.43420:43572](∅→∅),[3.61504]→[3.63089:63165](∅→∅),[3.43572]→[3.63089:63165](∅→∅),[3.49133]→[3.63089:63165](∅→∅),[3.55284]→[3.63089:63165](∅→∅),[3.108390]→[3.63089:63165](∅→∅)

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

[3.108238]

[3.63165]

"bytes 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"futures-sink 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
"pin-project-lite 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1434

[3.63180]→[3.55285:55311](∅→∅),[3.55311]→[3.43573:43591](∅→∅),[3.43591]→[3.55329:55394](∅→∅),[3.55329]→[3.55329:55394](∅→∅)

name = "tokio-trace-core"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"

[3.63180]

[3.55394]

name = "tokio-xmpp"
version = "2.0.0"
source = "git+https://gitlab.com/xmpp-rs/xmpp-rs#b85aa293770d22cca11fd7ca3802b5920e1ab6fa"
replacement in Cargo.lock at line 1438

[3.55411]→[3.55411:55489](∅→∅),[3.55411]→[3.55411:55489](∅→∅)

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

[3.55411]

[3.55489]

"bytes 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"idna 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
"native-tls 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
"sasl 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-tls 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-util 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"trust-dns-proto 0.19.5 (registry+https://github.com/rust-lang/crates.io-index)",
"trust-dns-resolver 0.19.5 (registry+https://github.com/rust-lang/crates.io-index)",
"xml5ever 0.16.1 (registry+https://github.com/rust-lang/crates.io-index)",
"xmpp-parsers 0.17.0 (git+https://gitlab.com/xmpp-rs/xmpp-rs)",
replacement in Cargo.lock at line 1454

[3.55504]→[3.108700:108719](∅→∅),[3.108700]→[3.108700:108719](∅→∅),[3.108719]→[3.83774:83792](∅→∅)

name = "tokio-udp"
version = "0.1.3"

[3.55504]

[3.108737]

name = "toml"
version = "0.5.6"
replacement in Cargo.lock at line 1458

[3.108819]→[3.55505:55578](∅→∅),[3.55578]→[3.43592:43667](∅→∅),[3.61653]→[3.83941:84011](∅→∅),[3.86219]→[3.83941:84011](∅→∅),[3.43667]→[3.83941:84011](∅→∅),[3.55653]→[3.83941:84011](∅→∅),[3.63533]→[3.83941:84011](∅→∅),[3.83941]→[3.83941:84011](∅→∅),[3.84011]→[3.43668:43739](∅→∅),[3.43739]→[3.109108:109186](∅→∅),[3.55725]→[3.109108:109186](∅→∅),[3.109108]→[3.109108:109186](∅→∅),[3.109186]→[3.63534:63690](∅→∅)

"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)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
"mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-codec 0.1.1 (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)",

[3.108819]

[3.109342]

"serde 1.0.115 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1462

[3.109357]→[3.109357:109376](∅→∅),[3.109357]→[3.109357:109376](∅→∅),[3.109357]→[3.109357:109376](∅→∅),[3.109357]→[3.109357:109376](∅→∅),[3.109357]→[3.109357:109376](∅→∅),[3.109376]→[3.84169:84187](∅→∅)

name = "tokio-uds"
version = "0.2.5"

[3.109357]

[3.109394]

name = "tower-service"
version = "0.3.0"
edit in Cargo.lock at line 1465

[3.109459]→[3.109459:109476](∅→∅),[3.109459]→[3.109459:109476](∅→∅),[3.109459]→[3.109459:109476](∅→∅),[3.109476]→[3.55726:55799](∅→∅),[3.55799]→[3.43740:43815](∅→∅),[3.84336]→[3.109624:109696](∅→∅),[3.61802]→[3.109624:109696](∅→∅),[3.71590]→[3.109624:109696](∅→∅),[3.86525]→[3.109624:109696](∅→∅),[3.43815]→[3.109624:109696](∅→∅),[3.55874]→[3.109624:109696](∅→∅),[3.63839]→[3.109624:109696](∅→∅),[3.109624]→[3.109624:109696](∅→∅),[3.109696]→[3.43816:43888](∅→∅),[3.61875]→[3.84409:84479](∅→∅),[3.86598]→[3.84409:84479](∅→∅),[3.43888]→[3.84409:84479](∅→∅),[3.49206]→[3.84409:84479](∅→∅),[3.55947]→[3.84409:84479](∅→∅),[3.63912]→[3.84409:84479](∅→∅),[3.84409]→[3.84409:84479](∅→∅),[3.84479]→[3.43889:43960](∅→∅),[3.43960]→[3.109909:109983](∅→∅),[3.56019]→[3.109909:109983](∅→∅),[3.109909]→[3.109909:109983](∅→∅),[3.109983]→[3.84480:84558](∅→∅),[3.84558]→[3.63913:64069](∅→∅),[3.84714]→[3.110217:110219](∅→∅),[3.71890]→[3.110217:110219](∅→∅),[3.86755]→[3.110217:110219](∅→∅),[3.64069]→[3.110217:110219](∅→∅),[3.110217]→[3.110217:110219](∅→∅)

dependencies = [
"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)",
"iovec 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)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
"mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
"mio-uds 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio-codec 0.1.1 (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)",
]
replacement in Cargo.lock at line 1467

[3.110232]→[3.110232:110252](∅→∅),[3.110232]→[3.110232:110252](∅→∅),[3.110232]→[3.110232:110252](∅→∅),[3.110232]→[3.110232:110252](∅→∅),[3.110232]→[3.110232:110252](∅→∅),[3.110252]→[3.84715:84733](∅→∅)

name = "tokio-xmpp"
version = "1.0.0"

[3.110232]

[3.110270]

name = "tracing"
version = "0.1.19"
replacement in Cargo.lock at line 1471

[3.110352]→[3.56020:56093](∅→∅),[3.84807]→[3.110425:110504](∅→∅),[3.61949]→[3.110425:110504](∅→∅),[3.71983]→[3.110425:110504](∅→∅),[3.86829]→[3.110425:110504](∅→∅),[3.56093]→[3.110425:110504](∅→∅),[3.64143]→[3.110425:110504](∅→∅),[3.110425]→[3.110425:110504](∅→∅),[3.110504]→[3.43961:44036](∅→∅),[3.84883]→[3.110579:110650](∅→∅),[3.62025]→[3.110579:110650](∅→∅),[3.72059]→[3.110579:110650](∅→∅),[3.86905]→[3.110579:110650](∅→∅),[3.44036]→[3.110579:110650](∅→∅),[3.56169]→[3.110579:110650](∅→∅),[3.64219]→[3.110579:110650](∅→∅),[3.110579]→[3.110579:110650](∅→∅),[3.110650]→[3.44037:44114](∅→∅),[3.62103]→[3.64220:64297](∅→∅),[3.44114]→[3.64220:64297](∅→∅),[3.49284]→[3.64220:64297](∅→∅),[3.56247]→[3.64220:64297](∅→∅),[3.110727]→[3.64220:64297](∅→∅),[3.86983]→[3.84961:85032](∅→∅),[3.64297]→[3.84961:85032](∅→∅),[3.84961]→[3.84961:85032](∅→∅),[3.85032]→[3.44115:44188](∅→∅),[3.85105]→[3.110948:111026](∅→∅),[3.62177]→[3.110948:111026](∅→∅),[3.72426]→[3.110948:111026](∅→∅),[3.87057]→[3.110948:111026](∅→∅),[3.44188]→[3.110948:111026](∅→∅),[3.49358]→[3.110948:111026](∅→∅),[3.56321]→[3.110948:111026](∅→∅),[3.64371]→[3.110948:111026](∅→∅),[3.110948]→[3.110948:111026](∅→∅),[3.111026]→[3.64372:64448](∅→∅),[3.87134]→[3.85182:85582](∅→∅),[3.64448]→[3.85182:85582](∅→∅),[3.85182]→[3.85182:85582](∅→∅)

"bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)",
"derive-error 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)",
"idna 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"native-tls 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
"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)",
"tokio-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"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)",
"xml5ever 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)",
"xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)",

[3.110352]

[3.111502]

"cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
"tracing-core 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1477

[3.111517]→[3.111517:111531](∅→∅),[3.111517]→[3.111517:111531](∅→∅),[3.111517]→[3.111517:111531](∅→∅),[3.111531]→[3.44189:44207](∅→∅)

name = "toml"
version = "0.5.0"

[3.111517]

[3.111549]

name = "tracing-core"
version = "0.1.15"
replacement in Cargo.lock at line 1481

[3.111631]→[3.44208:44281](∅→∅)

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

[3.111631]

[3.111704]

"lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1486

[3.111744]→[3.85676:85694](∅→∅)

version = "0.6.3"

[3.111744]

[3.111762]

version = "0.19.5"
replacement in Cargo.lock at line 1489

[3.111844]→[3.44282:44358](∅→∅),[3.44358]→[3.85771:85845](∅→∅),[3.56491]→[3.85771:85845](∅→∅),[3.85771]→[3.85771:85845](∅→∅),[3.85845]→[3.44359:44434](∅→∅),[3.85920]→[3.112069:112140](∅→∅),[3.62347]→[3.112069:112140](∅→∅),[3.73320]→[3.112069:112140](∅→∅),[3.87304]→[3.112069:112140](∅→∅),[3.44434]→[3.112069:112140](∅→∅),[3.56567]→[3.112069:112140](∅→∅),[3.64617]→[3.112069:112140](∅→∅),[3.112069]→[3.112069:112140](∅→∅),[3.112140]→[3.64618:64696](∅→∅),[3.87383]→[3.85999:86140](∅→∅),[3.64696]→[3.85999:86140](∅→∅),[3.85999]→[3.85999:86140](∅→∅),[3.86140]→[3.44435:44584](∅→∅),[3.44584]→[3.56718:56799](∅→∅),[3.56718]→[3.56718:56799](∅→∅),[3.62429]→[3.64854:65010](∅→∅),[3.56799]→[3.64854:65010](∅→∅),[3.64854]→[3.64854:65010](∅→∅),[3.87697]→[3.86453:86529](∅→∅),[3.65010]→[3.86453:86529](∅→∅),[3.86453]→[3.86453:86529](∅→∅),[3.86529]→[3.44585:44664](∅→∅),[3.44664]→[3.86608:86754](∅→∅),[3.56879]→[3.86608:86754](∅→∅),[3.86608]→[3.86608:86754](∅→∅)

"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)",
"idna 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
"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)",
"socket2 0.3.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)",
"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)",
"tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
"url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)",

[3.111844]

[3.113046]

"async-trait 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
"backtrace 0.3.50 (registry+https://github.com/rust-lang/crates.io-index)",
"enum-as-inner 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"idna 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
"smallvec 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"thiserror 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
"url 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1505

[3.113089]→[3.86755:86774](∅→∅)

version = "0.10.3"

[3.113089]

[3.113108]

version = "0.19.5"
replacement in Cargo.lock at line 1508

[3.113190]→[3.44665:44738](∅→∅),[3.62503]→[3.86848:86922](∅→∅),[3.87771]→[3.86848:86922](∅→∅),[3.44738]→[3.86848:86922](∅→∅),[3.56953]→[3.86848:86922](∅→∅),[3.65084]→[3.86848:86922](∅→∅),[3.86848]→[3.86848:86922](∅→∅),[3.86922]→[3.44739:44814](∅→∅),[3.62579]→[3.86997:87072](∅→∅),[3.87847]→[3.86997:87072](∅→∅),[3.44814]→[3.86997:87072](∅→∅),[3.57029]→[3.86997:87072](∅→∅),[3.65160]→[3.86997:87072](∅→∅),[3.86997]→[3.86997:87072](∅→∅),[3.87072]→[3.65161:65239](∅→∅),[3.87926]→[3.87150:87220](∅→∅),[3.65239]→[3.87150:87220](∅→∅),[3.87150]→[3.87150:87220](∅→∅)

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

[3.113190]

[3.57030]

"backtrace 0.3.50 (registry+https://github.com/rust-lang/crates.io-index)",
"cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"futures 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
"ipconfig 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1515

[3.62656]→[3.87296:87374](∅→∅),[3.88003]→[3.87296:87374](∅→∅),[3.57106]→[3.87296:87374](∅→∅),[3.65316]→[3.87296:87374](∅→∅),[3.87296]→[3.87296:87374](∅→∅),[3.87374]→[3.44815:44963](∅→∅),[3.62730]→[3.87522:87604](∅→∅),[3.88152]→[3.87522:87604](∅→∅),[3.44963]→[3.87522:87604](∅→∅),[3.49432]→[3.87522:87604](∅→∅),[3.57256]→[3.87522:87604](∅→∅),[3.65465]→[3.87522:87604](∅→∅),[3.87522]→[3.87522:87604](∅→∅)

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

[3.57106]

[3.114019]

"resolv-conf 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
"smallvec 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
"thiserror 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)",
"tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)",
"trust-dns-proto 0.19.5 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1524

[3.114052]→[3.114052:114070](∅→∅),[3.114052]→[3.114052:114070](∅→∅),[3.114052]→[3.114052:114070](∅→∅)

version = "0.2.2"

[3.114052]

[3.114070]

version = "0.2.3"
edit in Cargo.lock at line 1528

[3.114148]→[3.114148:114166](∅→∅),[3.114148]→[3.114148:114166](∅→∅),[3.114148]→[3.114148:114166](∅→∅),[3.114166]→[3.87605:87623](∅→∅),[3.87623]→[3.114184:114249](∅→∅),[3.75026]→[3.114184:114249](∅→∅),[3.114184]→[3.114184:114249](∅→∅),[3.114249]→[3.87624:87641](∅→∅),[3.87641]→[3.44964:45037](∅→∅),[3.62804]→[3.87714:87716](∅→∅),[3.88226]→[3.87714:87716](∅→∅),[3.45037]→[3.87714:87716](∅→∅),[3.57330]→[3.87714:87716](∅→∅),[3.65539]→[3.87714:87716](∅→∅),[3.87714]→[3.87714:87716](∅→∅),[3.87716]→[3.114341:114354](∅→∅),[3.114341]→[3.114341:114354](∅→∅)

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

[[package]]
replacement in Cargo.lock at line 1529

[3.114371]→[3.114371:114390](∅→∅),[3.114371]→[3.114371:114390](∅→∅)

version = "1.10.0"

[3.114371]

[3.114390]

version = "1.12.0"
edit in Cargo.lock at line 1533

[3.114468]→[3.114468:114486](∅→∅),[3.114468]→[3.114468:114486](∅→∅),[3.114486]→[3.87717:87735](∅→∅),[3.87735]→[3.114504:114582](∅→∅),[3.75045]→[3.114504:114582](∅→∅),[3.114504]→[3.114504:114582](∅→∅)

name = "ucd-util"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
replacement in Cargo.lock at line 1542

[3.114824]→[3.87736:87754](∅→∅)

version = "0.1.8"

[3.114824]

[3.114842]

version = "0.1.13"
replacement in Cargo.lock at line 1545

[3.87772]→[3.45038:45113](∅→∅)

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

[3.87772]

[3.87847]

"tinyvec 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1549

[3.115014]→[3.115014:115055](∅→∅),[3.115014]→[3.115014:115055](∅→∅)

name = "unicode-width"
version = "0.1.5"

[3.115014]

[3.115055]

name = "unicode-segmentation"
version = "1.6.0"
replacement in Cargo.lock at line 1554

[3.115133]→[3.115133:115172](∅→∅),[3.115133]→[3.115133:115172](∅→∅)

name = "unicode-xid"
version = "0.0.4"

[3.115133]

[3.115172]

name = "unicode-width"
version = "0.1.8"
replacement in Cargo.lock at line 1560

[3.115271]→[3.43797:43815](∅→∅),[3.12238]→[3.43797:43815](∅→∅)

version = "0.1.0"

[3.115271]

[3.115272]

version = "0.2.1"
replacement in Cargo.lock at line 1565

[3.115363]→[3.87850:87868](∅→∅)

version = "1.7.2"

[3.115363]

[3.115381]

version = "2.1.1"
replacement in Cargo.lock at line 1568

[3.115463]→[3.115463:115534](∅→∅),[3.115463]→[3.115463:115534](∅→∅),[3.115463]→[3.115463:115534](∅→∅)

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

[3.115463]

[3.115534]

"idna 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1570

[3.115608]→[3.115608:115691](∅→∅),[3.115608]→[3.115608:115691](∅→∅),[3.115608]→[3.115608:115691](∅→∅)

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

[3.115608]

[3.115691]

"percent-encoding 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 1576

[3.87887]→[3.115739:115838](∅→∅),[3.75310]→[3.115739:115838](∅→∅),[3.115739]→[3.115739:115838](∅→∅),[3.115838]→[3.45114:45132](∅→∅)

source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
name = "utf8-ranges"
version = "1.0.2"
replacement in Cargo.lock at line 1580

[3.115949]→[3.115949:115967](∅→∅),[3.115949]→[3.115949:115967](∅→∅),[3.115949]→[3.115949:115967](∅→∅),[3.115949]→[3.115949:115967](∅→∅),[3.115949]→[3.115949:115967](∅→∅)

version = "0.2.6"

[3.115949]

[3.115967]

version = "0.2.10"
replacement in Cargo.lock at line 1585

[3.116062]→[3.116062:116080](∅→∅),[3.116062]→[3.116062:116080](∅→∅),[3.116062]→[3.116062:116080](∅→∅),[3.116062]→[3.116062:116080](∅→∅),[3.116062]→[3.116062:116080](∅→∅)

version = "0.8.1"

[3.116062]

[3.116080]

version = "0.8.2"
replacement in Cargo.lock at line 1590

[3.116172]→[3.116172:116190](∅→∅),[3.116172]→[3.116172:116190](∅→∅)

version = "0.0.6"

[3.116172]

[3.116190]

version = "0.3.0"
replacement in Cargo.lock at line 1593

[3.116272]→[3.45133:45208](∅→∅),[3.62880]→[3.87982:88052](∅→∅),[3.88697]→[3.87982:88052](∅→∅),[3.45208]→[3.87982:88052](∅→∅),[3.57502]→[3.87982:88052](∅→∅),[3.65691]→[3.87982:88052](∅→∅),[3.87982]→[3.87982:88052](∅→∅),[3.88052]→[3.116417:116492](∅→∅),[3.75705]→[3.116417:116492](∅→∅),[3.116417]→[3.116417:116492](∅→∅)

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

[3.116272]

[3.116492]

"log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
"try-lock 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 1596

[3.116494]

[3.116494]

[[package]]
name = "wasi"
version = "0.9.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
name = "wasi"
version = "0.10.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
replacement in Cargo.lock at line 1609

[3.116527]→[3.116527:116545](∅→∅),[3.116527]→[3.116527:116545](∅→∅),[3.116527]→[3.116527:116545](∅→∅)

version = "0.2.2"

[3.116527]

[3.116545]

version = "0.4.2"
replacement in Cargo.lock at line 1619

[3.116751]→[3.57503:57521](∅→∅)

version = "0.3.7"

[3.116751]

[3.116769]

version = "0.3.9"
replacement in Cargo.lock at line 1638

[3.117325]→[3.88072:88090](∅→∅)

version = "0.1.2"

[3.117325]

[3.117343]

version = "0.1.5"
replacement in Cargo.lock at line 1641

[3.117425]→[3.57522:57595](∅→∅)

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

[3.117425]

[3.117498]

"winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 1650

[3.117647]→[3.117647:117765](∅→∅),[3.117765]→[3.57596:57669](∅→∅),[3.63047]→[3.88238:88316](∅→∅),[3.88864]→[3.88238:88316](∅→∅),[3.57669]→[3.88238:88316](∅→∅),[3.65858]→[3.88238:88316](∅→∅),[3.88238]→[3.88238:88316](∅→∅),[3.88316]→[3.117916:117931](∅→∅),[3.75969]→[3.117916:117931](∅→∅),[3.117916]→[3.117916:117931](∅→∅)

name = "wincolor"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"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)",
]

[[package]]
replacement in Cargo.lock at line 1651

[3.117947]→[3.117947:117965](∅→∅),[3.117947]→[3.117947:117965](∅→∅),[3.117947]→[3.117947:117965](∅→∅)

version = "0.5.1"

[3.117947]

[3.117965]

version = "0.6.2"
replacement in Cargo.lock at line 1654

[3.118047]→[3.57670:57743](∅→∅)

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

[3.118047]

[3.118120]

"winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
edit in Cargo.lock at line 1658

[3.118135]→[3.118135:118252](∅→∅),[3.118135]→[3.118135:118252](∅→∅),[3.118135]→[3.118135:118252](∅→∅),[3.118135]→[3.118135:118252](∅→∅),[3.118135]→[3.118135:118252](∅→∅),[3.118135]→[3.118135:118252](∅→∅),[3.118135]→[3.118135:118252](∅→∅),[3.118252]→[3.57744:57817](∅→∅),[3.88464]→[3.118325:118340](∅→∅),[3.63195]→[3.118325:118340](∅→∅),[3.76117]→[3.118325:118340](∅→∅),[3.89012]→[3.118325:118340](∅→∅),[3.57817]→[3.118325:118340](∅→∅),[3.66006]→[3.118325:118340](∅→∅),[3.118325]→[3.118325:118340](∅→∅)

name = "winutil"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
]

[[package]]
replacement in Cargo.lock at line 1668

[3.118645]→[3.88465:88484](∅→∅)

version = "0.12.1"

[3.118645]

[3.118664]

version = "0.16.1"
replacement in Cargo.lock at line 1671

[3.118746]→[3.88485:88555](∅→∅)

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

[3.118746]

[3.118816]

"log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1673

[3.118886]→[3.88556:88706](∅→∅),[3.88706]→[3.119036:119073](∅→∅),[3.76359]→[3.119036:119073](∅→∅),[3.119036]→[3.119036:119073](∅→∅),[3.119073]→[3.88707:88726](∅→∅),[3.88726]→[3.119092:119174](∅→∅),[3.76379]→[3.119092:119174](∅→∅),[3.119092]→[3.119092:119174](∅→∅),[3.119174]→[3.88727:88874](∅→∅),[3.88874]→[3.120186:120259](∅→∅),[3.76526]→[3.120186:120259](∅→∅),[3.120186]→[3.120186:120259](∅→∅),[3.120259]→[3.88875:89236](∅→∅),[3.89236]→[3.45209:45280](∅→∅),[3.63267]→[3.89307:89382](∅→∅),[3.45280]→[3.89307:89382](∅→∅),[3.49504]→[3.89307:89382](∅→∅),[3.57889]→[3.89307:89382](∅→∅),[3.89307]→[3.89307:89382](∅→∅)

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

[3.118886]

[3.57890]

"markup5ever 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
"time 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1679

[3.57927]→[3.57927:58011](∅→∅)

version = "0.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"

[3.57927]

[3.58011]

version = "0.17.0"
source = "git+https://gitlab.com/xmpp-rs/xmpp-rs#b85aa293770d22cca11fd7ca3802b5920e1ab6fa"
replacement in Cargo.lock at line 1682

[3.58028]→[3.58028:58609](∅→∅),[3.58609]→[3.45281:45352](∅→∅)

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

[3.58028]

[3.120691]

"base64 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)",
"blake2 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
"chrono 0.4.15 (registry+https://github.com/rust-lang/crates.io-index)",
"digest 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
"jid 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
"minidom 0.12.0 (git+https://gitlab.com/xmpp-rs/xmpp-rs)",
"sha-1 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
"sha2 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
"sha3 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
replacement in Cargo.lock at line 1694

[3.120705]→[3.45353:45508](∅→∅),[3.45508]→[3.58681:58836](∅→∅),[3.120705]→[3.58681:58836](∅→∅)

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

[3.120705]

[3.121015]

"checksum addr2line 0.13.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1b6a2d3371669ab3ca9797670853d61402b03d0b4b9ebf33d677dfa720203072"
"checksum adler 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ee2a4ec343196209d6594e19543ae87a39f96d5534d7174822a3ad825dd6ed7e"
"checksum aho-corasick 0.7.13 (registry+https://github.com/rust-lang/crates.io-index)" = "043164d8ba5c4c3035fec9bbee8647c0261d788f3474306f93bb65901cae0e86"
replacement in Cargo.lock at line 1698

[3.121168]→[3.45509:45661](∅→∅),[3.63731]→[3.90636:90788](∅→∅),[3.89320]→[3.90636:90788](∅→∅),[3.45661]→[3.90636:90788](∅→∅),[3.49729]→[3.90636:90788](∅→∅),[3.58989]→[3.90636:90788](∅→∅),[3.67106]→[3.90636:90788](∅→∅),[3.90636]→[3.90636:90788](∅→∅),[3.90788]→[3.121472:121620](∅→∅),[3.77643]→[3.121472:121620](∅→∅),[3.121472]→[3.121472:121620](∅→∅),[3.121620]→[3.45662:45965](∅→∅),[3.63885]→[3.91092:91249](∅→∅),[3.89474]→[3.91092:91249](∅→∅),[3.45965]→[3.91092:91249](∅→∅),[3.59293]→[3.91092:91249](∅→∅),[3.67260]→[3.91092:91249](∅→∅),[3.91092]→[3.91092:91249](∅→∅)

"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"
"checksum atty 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "9a7d5b8723950951411ee34d271d99dddcc2035a16ab25310ea2c8cfd4369652"
"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"

[3.121168]

[3.91249]

"checksum arc-swap 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)" = "4d25d88fd6b8041580a654f9d0c581a047baee2b3efee13275f2fc392fc75034"
"checksum async-trait 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "687c230d85c0a52504709705fc8a53e4a692b83a2184f03dae73e38e1e93a783"
"checksum atty 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)" = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
"checksum autocfg 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
"checksum backtrace 0.3.50 (registry+https://github.com/rust-lang/crates.io-index)" = "46254cf2fdcdf1badb5934448c1bcbe046a56537b3987d96c51a7afc5d03f293"
replacement in Cargo.lock at line 1704

[3.91399]→[3.45966:46117](∅→∅),[3.46117]→[3.91400:91549](∅→∅),[3.59445]→[3.91400:91549](∅→∅),[3.122381]→[3.91400:91549](∅→∅),[3.91549]→[3.46118:46429](∅→∅)

"checksum bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "228047a76f468627ca71776ecdebd732a3423081fcf5125585bcd7c49886ce12"
"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"

[3.91399]

[3.91860]

"checksum base64 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3441f0f7b02788e948e47f457ca01f1d7e6d92c693bc132c22b087d3141c03ff"
"checksum bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
"checksum blake2 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "94cb07b0da6a73955f8fb85d24c466778e70cda767a568229b104f0264089330"
"checksum block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
"checksum block-padding 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
replacement in Cargo.lock at line 1710

[3.92013]→[3.46430:46582](∅→∅),[3.46582]→[3.59910:60059](∅→∅),[3.59910]→[3.59910:60059](∅→∅),[3.92314]→[3.123295:123442](∅→∅),[3.64347]→[3.123295:123442](∅→∅),[3.79013]→[3.123295:123442](∅→∅),[3.89780]→[3.123295:123442](∅→∅),[3.60059]→[3.123295:123442](∅→∅),[3.67566]→[3.123295:123442](∅→∅),[3.123295]→[3.123295:123442](∅→∅),[3.123442]→[3.46583:46878](∅→∅),[3.92610]→[3.123737:123886](∅→∅),[3.64643]→[3.123737:123886](∅→∅),[3.79309]→[3.123737:123886](∅→∅),[3.90076]→[3.123737:123886](∅→∅),[3.46878]→[3.123737:123886](∅→∅),[3.60355]→[3.123737:123886](∅→∅),[3.67862]→[3.123737:123886](∅→∅),[3.123737]→[3.123737:123886](∅→∅),[3.123886]→[3.60356:60504](∅→∅)

"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"
"checksum case 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e88b166b48e29667f5443df64df3c61dc07dc2b1a0b0d231800e07f09a33ecc1"
"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"
"checksum chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "45912881121cb26fad7c38c17ba7daa18764771836b34fab7d3fbd93ed633878"
"checksum clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5067f5bb2d80ef5d68b4c87db81601f0b75bca627bc2ef76b141d7b846a3c6d9"

[3.92013]

[3.124034]

"checksum byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
"checksum bytes 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)" = "0e4cec68f03f32e44924783795810fa50a7035d8c8ebe78580ad7e6c703fba38"
"checksum cc 1.0.59 (registry+https://github.com/rust-lang/crates.io-index)" = "66120af515773fb005778dc07c261bd201ec8ce50bd6e7144c927753fe013381"
"checksum cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
"checksum chrono 0.4.15 (registry+https://github.com/rust-lang/crates.io-index)" = "942f72db697d8767c22d46a598e01f2d3b475501ea43d0db4f16d90259182d0b"
"checksum clap 2.33.3 (registry+https://github.com/rust-lang/crates.io-index)" = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"
replacement in Cargo.lock at line 1717

[3.124185]→[3.46879:47199](∅→∅),[3.65113]→[3.68012:68170](∅→∅),[3.47199]→[3.68012:68170](∅→∅),[3.50362]→[3.68012:68170](∅→∅),[3.60825]→[3.68012:68170](∅→∅),[3.124505]→[3.68012:68170](∅→∅),[3.90696]→[3.92918:93076](∅→∅),[3.68170]→[3.92918:93076](∅→∅),[3.92918]→[3.92918:93076](∅→∅),[3.93076]→[3.68171:68329](∅→∅),[3.68329]→[3.93234:93392](∅→∅),[3.93234]→[3.93234:93392](∅→∅)

"checksum core-foundation 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "286e0b41c3a20da26536c6000a280585d519fd07b3956b43aed8a79e9edce980"
"checksum core-foundation-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "716c271e8613ace48344f723b60b900a93150271e5be206212d052bbc0883efa"
"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"

[3.124185]

[3.93392]

"checksum core-foundation 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "57d24c7a13c43e870e37c1556b74555437870a04514f7685f5b354e090567171"
"checksum core-foundation-sys 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b3a71ab494c0b5b860bdc8407ae08978052417070c2ced38573a9157ad75b8ac"
replacement in Cargo.lock at line 1720

[3.93545]→[3.125290:125445](∅→∅),[3.80400]→[3.125290:125445](∅→∅),[3.125290]→[3.125290:125445](∅→∅),[3.125445]→[3.93546:93695](∅→∅),[3.60975]→[3.68330:68485](∅→∅),[3.93695]→[3.68330:68485](∅→∅),[3.68485]→[3.60976:61129](∅→∅),[3.94003]→[3.125902:126056](∅→∅),[3.65267]→[3.125902:126056](∅→∅),[3.81014]→[3.125902:126056](∅→∅),[3.91005]→[3.125902:126056](∅→∅),[3.61129]→[3.125902:126056](∅→∅),[3.68638]→[3.125902:126056](∅→∅),[3.125902]→[3.125902:126056](∅→∅),[3.126056]→[3.94004:94311](∅→∅)

"checksum derive-error 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "ec098440b29ea3b1ece3e641bac424c19cf996779b623c9e0f2171495425c2c8"
"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"
"checksum error-chain 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "6930e04918388a9a2e41d518c25cf679ccafe26733fb4127dbf21993f2575d46"
"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"

[3.93545]

[3.126363]

"checksum digest 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
"checksum enum-as-inner 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7c5f0096a91d210159eceb2ff5e1c4da18388a170e1e3ce948aac9c8fdbbf595"
"checksum env_logger 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36"
"checksum failure 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "d32e9bd16cc02eae7db7ef620b392808b89f6a5e16bb3497d159c6b92a0f4f86"
"checksum failure_derive 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "aa4da3c766cd7a0db8242e326e9e4e081edd567072893ed320008189715366a4"
replacement in Cargo.lock at line 1726

[3.126515]→[3.126515:126661](∅→∅),[3.126515]→[3.126515:126661](∅→∅),[3.126515]→[3.126515:126661](∅→∅)

"checksum fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "2fad85553e09a6f881f739c29f0b00b0f01357c743266d478b68951ce23285f3"

[3.126515]

[3.126661]

"checksum fnv 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
replacement in Cargo.lock at line 1733

[3.127601]→[3.47200:47351](∅→∅),[3.94620]→[3.127752:127910](∅→∅),[3.65419]→[3.127752:127910](∅→∅),[3.81474]→[3.127752:127910](∅→∅),[3.91157]→[3.127752:127910](∅→∅),[3.47351]→[3.127752:127910](∅→∅),[3.61281]→[3.127752:127910](∅→∅),[3.68790]→[3.127752:127910](∅→∅),[3.127752]→[3.127752:127910](∅→∅),[3.127910]→[3.94621:94778](∅→∅),[3.94778]→[3.47352:47498](∅→∅),[3.65566]→[3.94924:95071](∅→∅),[3.91304]→[3.94924:95071](∅→∅),[3.47498]→[3.94924:95071](∅→∅),[3.61428]→[3.94924:95071](∅→∅),[3.68937]→[3.94924:95071](∅→∅),[3.94924]→[3.94924:95071](∅→∅),[3.95071]→[3.128360:128511](∅→∅),[3.81777]→[3.128360:128511](∅→∅),[3.128360]→[3.128360:128511](∅→∅),[3.128511]→[3.61429:61577](∅→∅),[3.95220]→[3.128659:128810](∅→∅),[3.65715]→[3.128659:128810](∅→∅),[3.81926]→[3.128659:128810](∅→∅),[3.91453]→[3.128659:128810](∅→∅),[3.61729]→[3.128659:128810](∅→∅),[3.69086]→[3.128659:128810](∅→∅),[3.128659]→[3.128659:128810](∅→∅),[3.128810]→[3.95221:95373](∅→∅),[3.95373]→[3.47499:47649](∅→∅),[3.95523]→[3.129112:129558](∅→∅),[3.65866]→[3.129112:129558](∅→∅),[3.82229]→[3.129112:129558](∅→∅),[3.91604]→[3.129112:129558](∅→∅),[3.47649]→[3.129112:129558](∅→∅),[3.61880]→[3.129112:129558](∅→∅),[3.69237]→[3.129112:129558](∅→∅),[3.129112]→[3.129112:129558](∅→∅),[3.129558]→[3.95524:95675](∅→∅),[3.95675]→[3.47650:47797](∅→∅),[3.47797]→[3.95676:95822](∅→∅),[3.62028]→[3.95676:95822](∅→∅),[3.129856]→[3.95676:95822](∅→∅)

"checksum futures 0.1.26 (registry+https://github.com/rust-lang/crates.io-index)" = "62941eff9507c8177d448bd83a44d9b9760856e184081d8cd79ba9f03dd24981"
"checksum futures-cpupool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "ab90cde24b3319636588d0c35fe03b1333857621051837ed769faefb4c2162e4"
"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"
"checksum hostname 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "21ceb46a83a85e824ef93669c8b390009623863b5c195d1ba747292c0c72f94e"
"checksum http 0.1.17 (registry+https://github.com/rust-lang/crates.io-index)" = "eed324f0f0daf6ec10c474f150505af2c143f251722bf9dbd1261bd1f2ee2c1a"
"checksum httparse 1.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e8734b0cfd3bc3e101ec59100e101c2eecd19282202e87808b3037b442777a83"
"checksum humantime 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3ca7e5f2e110db35f93b837c81797f3714500b81d517bf20c431b16d3ca4f114"
"checksum hyper 0.12.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4f2777434f26af6e4ce4fdcdccd3bed9d861d11e87bcbe72c0f51ddaca8ff848"
"checksum idna 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "38f09e0f0b1fb55fdee1f17470ad800da77af5186a1a76c026b679358b7e844e"
"checksum indexmap 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7e81a7c05f79578dbc15793d8b619db9ba32b4577003ef3af1a91c416798c58d"
"checksum iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dbe6e417e7d0975db6512b90796e8ce223145ac4e33c377e4a42882a0e88bb08"
"checksum ipconfig 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "08f7eadeaf4b52700de180d147c4805f199854600b36faa963d91114827b2ffc"
"checksum itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1306f3464951f30e30d12373d31c79fbd52d236e5e896fd92f96ec7babbbe60b"
"checksum jid 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "24e8a3f2ab860aa08074136e3144a2425e678d8823206e5adcc6145dc136503a"

[3.127601]

[3.130002]

"checksum futures 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "1e05b85ec287aac0dc34db7d4a569323df697f9c55b99b15d6b4ef8cde49f613"
"checksum futures-channel 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "f366ad74c28cca6ba456d95e6422883cfb4b252a83bed929c83abfdbbf2967d5"
"checksum futures-core 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "59f5fff90fd5d971f936ad674802482ba441b6f09ba5e15fd8b39145582ca399"
"checksum futures-executor 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "10d6bb888be1153d3abeb9006b11b02cf5e9b209fda28693c31ae1e4e012e314"
"checksum futures-io 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "de27142b013a8e869c14957e6d2edeef89e97c289e69d042ee3a49acd8b51789"
"checksum futures-macro 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "d0b5a30a4328ab5473878237c447333c093297bded83a4983d10f4deea240d39"
"checksum futures-sink 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "3f2032893cb734c7a05d85ce0cc8b8c4075278e93b24b66f9de99d6eb0fa8acc"
"checksum futures-task 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "bdb66b5f09e22019b1ab0830f7785bcea8e7a42148683f99214f73f8ec21a626"
"checksum futures-util 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "8764574ff08b701a084482c3c7031349104b07ac897393010494beaa18ce32c6"
"checksum generic-array 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)" = "c68f0274ae0e023facc3c97b2e00f076be70e254bc851d972503b328db79b2ec"
"checksum getrandom 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "7abc8dd8451921606d809ba32e95b6111925cd2906060d2dcc29c070220503eb"
"checksum gimli 0.22.0 (registry+https://github.com/rust-lang/crates.io-index)" = "aaf91faf136cb47367fa430cd46e37a788775e7fa104f8b4bcb3861dc389b724"
"checksum h2 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "993f9e0baeed60001cf565546b0d3dbe6a6ad23f2bd31644a133c641eccf6d53"
"checksum hashbrown 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "00d63df3d41950fb462ed38308eea019113ad1508da725bbedcd0fa5a85ef5f7"
"checksum heck 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "20564e78d53d2bb135c343b3f47714a56af2061f1c928fdb541dc7b9fdd94205"
"checksum hermit-abi 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "3deed196b6e7f9e44a2ae8d94225d80302d81208b1bb673fd21fe634645c85a9"
"checksum hmac 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5dcb5e64cda4c23119ab41ba960d1e170a774c8e4b9d9e6a9bc18aabf5e59695"
"checksum hostname 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3c731c3e10504cc8ed35cfe2f1db4c9274c3d35fa486e3b31df46f068ef3e867"
"checksum http 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "28d569972648b2c512421b5f2a405ad6ac9666547189d0c5477a3f200f3e02f9"
"checksum http-body 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "13d5ff830006f7646652e057693569bfe0d51760c0085a071769d142a205111b"
"checksum httparse 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "cd179ae861f0c2e53da70d892f5f3029f9594be0c41dc5269cd371691b1dc2f9"
"checksum humantime 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "df004cfca50ef23c36850aaaa59ad52cc70d0e90243c3c7737a4dd32dc7a3c4f"
"checksum hyper 0.13.7 (registry+https://github.com/rust-lang/crates.io-index)" = "3e68a8dd9716185d9e64ea473ea6ef63529252e3e27623295a0378a19665d5eb"
"checksum idna 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "02e2673c30ee86b5b96a9cb52ad15718aa1f966f5ab9ad54a8b95d5ca33120a9"
"checksum indexmap 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "55e2e4c765aa53a0424761bf9f41aa7a6ac1efa87238f59560640e27fca028f2"
"checksum iovec 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e"
"checksum ipconfig 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f7e2f18aece9709094573a9f24f483c4f65caa4298e2f7ae1b71cc65d853fad7"
"checksum itoa 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6"
"checksum jid 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3d9f987c3ff1c2c7d477c9e0a3dc25cc58ea97692b19a53018089109445b4ab3"
replacement in Cargo.lock at line 1764

[3.130306]→[3.69238:69392](∅→∅),[3.69392]→[3.47798:48097](∅→∅),[3.48097]→[3.62177:62335](∅→∅),[3.62177]→[3.62177:62335](∅→∅),[3.66173]→[3.96434:96731](∅→∅),[3.92066]→[3.96434:96731](∅→∅),[3.62335]→[3.96434:96731](∅→∅),[3.69699]→[3.96434:96731](∅→∅),[3.96434]→[3.96434:96731](∅→∅)

"checksum lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bc5729f27f159ddd61f4df6228e827e86643d4d3e7c32183cb30a1c08f604a14"
"checksum lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b294d6fa9ee409a054354afc4352b0b9ef7ca222c69b8812cbea9e7d2bf3783f"
"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"
"checksum lock_api 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "62ebf1391f6acad60e5c8b43706dde4582df75c06698ab44511d15016bc2442c"
"checksum log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c84ec4b527950aa83a329754b01dbe3f58361d1c5efacd1f6d68c494d08a17c6"

[3.130306]

[3.62336]

"checksum lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
"checksum libc 0.2.76 (registry+https://github.com/rust-lang/crates.io-index)" = "755456fae044e6fa1ebbbd1b3e902ae19e73097ed4ed87bb79934a867c007bc3"
"checksum linked-hash-map 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8dd5a6d5999d9907cda8ed67bbd137d3af8085216c2ac62de5be860bd41f304a"
"checksum log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "4fabed175da42fed1fa0746b0ea71f412aa9d35e76e95e59b192c64b9dc2bf8b"
replacement in Cargo.lock at line 1770

[3.131512]→[3.96884:97038](∅→∅)

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

[3.131512]

[3.131666]

"checksum markup5ever 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "aae38d669396ca9b707bfc3db254bc382ddb94f57cc5c235f34623a669a01dab"
"checksum match_cfg 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ffbee8634e0d45d258acb448e7eaab3fce7a0a467395d4d9f228e3c1f01fb2e4"
replacement in Cargo.lock at line 1773

[3.131816]→[3.69853:70002](∅→∅),[3.97188]→[3.131965:132117](∅→∅),[3.84040]→[3.131965:132117](∅→∅),[3.92369]→[3.131965:132117](∅→∅),[3.70002]→[3.131965:132117](∅→∅),[3.131965]→[3.131965:132117](∅→∅),[3.132117]→[3.97189:97340](∅→∅),[3.97340]→[3.48098:48245](∅→∅),[3.48245]→[3.132415:132565](∅→∅),[3.62636]→[3.132415:132565](∅→∅),[3.132415]→[3.132415:132565](∅→∅)

"checksum memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2efc7bc57c883d4a4d6e3246905283d8dae951bb3bd32f49d6ef297f546e1c39"
"checksum memoffset 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0f9dc261e2b62d7a622bf416ea3c5245cdd5d9a7fcc428c0d06804dfce1775b3"
"checksum minidom 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "275024eea6c6ff4ace22f2750843831183785288eec1cff91a4e6b8898cf94f9"
"checksum mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)" = "71646331f2619b1026cc302f87a2b8b648d5c6dd6937846a16cc8ce0f347f432"
"checksum mio-uds 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)" = "966257a94e196b11bb43aca423754d87429960a768de9414f3691d6957abf125"

[3.131816]

[3.132565]

"checksum memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400"
"checksum minidom 0.12.0 (git+https://gitlab.com/xmpp-rs/xmpp-rs)" = "<none>"
"checksum miniz_oxide 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4d7559a8a40d0f97e1edea3220f698f78b1c5ab67532e49f68fde3910323b722"
"checksum mio 0.6.22 (registry+https://github.com/rust-lang/crates.io-index)" = "fce347092656428bc8eaf6201042cb551b8d67855af7374542a92a0fbfcac430"
"checksum mio-uds 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "afcb699eb26d4332647cc848492bbc15eafb26f08d0304550d5aa1f612e066f0"
replacement in Cargo.lock at line 1779

[3.132712]→[3.48246:48399](∅→∅),[3.66480]→[3.132865:133013](∅→∅),[3.48399]→[3.132865:133013](∅→∅),[3.50665]→[3.132865:133013](∅→∅),[3.62790]→[3.132865:133013](∅→∅),[3.132865]→[3.132865:133013](∅→∅),[3.133013]→[3.70003:70167](∅→∅),[3.92534]→[3.97505:97655](∅→∅),[3.70167]→[3.97505:97655](∅→∅),[3.97505]→[3.97505:97655](∅→∅),[3.97655]→[3.48400:48860](∅→∅),[3.92686]→[3.97808:97963](∅→∅),[3.48860]→[3.97808:97963](∅→∅),[3.50815]→[3.97808:97963](∅→∅),[3.63400]→[3.97808:97963](∅→∅),[3.70320]→[3.97808:97963](∅→∅),[3.97808]→[3.97808:97963](∅→∅),[3.97963]→[3.48861:49013](∅→∅)

"checksum native-tls 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "ff8e08de0070bbf4c31f452ea2a70db092f36f6f2e4d897adf5674477d488fb2"
"checksum net2 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)" = "42550d9fb7b6684a6d404d9fa7250c2eb2646df731d1c06afc06dcee9e1bcf88"
"checksum new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f40f005c60db6e03bae699e414c58bf9aa7ea02a2d0b9bfbcf19286cc4c82b30"
"checksum nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "2f9667ddcc6cc8a43afc9b7917599d7216aa09c463919ea32c59ed6cac8bc945"
"checksum num-integer 0.1.39 (registry+https://github.com/rust-lang/crates.io-index)" = "e83d528d2677f0518c570baf2b7abdcf0cd2d248860b68507bdcb3e91d4c0cea"
"checksum num-traits 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "0b3a5d7cc97d6d30d8b9bc8fa19bf45349ffe46241e8816f50f62f6d6aaabee1"
"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"

[3.132712]

[3.134094]

"checksum native-tls 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "2b0d88c06fe90d5ee94048ba40409ef1d9315d86f6f38c2efdaad4fb50c58b2d"
"checksum net2 0.2.35 (registry+https://github.com/rust-lang/crates.io-index)" = "3ebc3ec692ed7c9a255596c67808dee269f64655d8baf7b4f0638e51ba1d6853"
"checksum new_debug_unreachable 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54"
"checksum num-integer 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "8d59457e662d541ba17869cf51cf177c0b5f0cbf476c66bdc90bf1edac4f875b"
"checksum num-traits 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)" = "ac267bcc07f48ee5f8935ab0d24f316fb722d7a1292e2913f0cc196b29ffd611"
"checksum num_cpus 1.13.0 (registry+https://github.com/rust-lang/crates.io-index)" = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3"
"checksum object 0.20.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1ab52be62400ca80aa00285d25253d7f7c437b7375c4de678f5405d3afe82ca5"
"checksum once_cell 1.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "260e51e7efe62b592207e9e13a68e43692a7a279171d6ba57abd208bf23645ad"
"checksum opaque-debug 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
"checksum openssl 0.10.30 (registry+https://github.com/rust-lang/crates.io-index)" = "8d575eff3665419f9b83678ff2815858ad9d11567e082f5ac1814baba4e2bcb4"
replacement in Cargo.lock at line 1790

[3.134250]→[3.49014:49169](∅→∅),[3.66789]→[3.98271:98737](∅→∅),[3.92995]→[3.98271:98737](∅→∅),[3.49169]→[3.98271:98737](∅→∅),[3.63709]→[3.98271:98737](∅→∅),[3.70629]→[3.98271:98737](∅→∅),[3.98271]→[3.98271:98737](∅→∅)

"checksum openssl-sys 0.9.43 (registry+https://github.com/rust-lang/crates.io-index)" = "33c86834957dd5b915623e94f2f4ab2c70dd8f6b70679824155d5ae21dbd495d"
"checksum owning_ref 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "49a4b8ea2179e6a2e27411d3bca09ca6dd630821cf6894c6c7c8467a8ee7ef13"
"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"

[3.134250]

[3.98737]

"checksum openssl-sys 0.9.58 (registry+https://github.com/rust-lang/crates.io-index)" = "a842db4709b604f0fe5d1170ae3565899be2ad3d9cbc72dedc789ac0511f78de"
replacement in Cargo.lock at line 1792

[3.98886]→[3.135020:135179](∅→∅),[3.85432]→[3.135020:135179](∅→∅),[3.135020]→[3.135020:135179](∅→∅),[3.135179]→[3.98887:99500](∅→∅),[3.99500]→[3.135792:135946](∅→∅),[3.86046]→[3.135792:135946](∅→∅),[3.135792]→[3.135792:135946](∅→∅)

"checksum percent-encoding 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "31010dd2e1ac33d5b46a5b413495239882813e0369f8ed8a5e266f173602f831"
"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"
"checksum pkg-config 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)" = "676e8eb2b1b4c9043511a9b7bea0915320d7e502b0a079fb03f9635a5252b18c"

[3.98886]

[3.135946]

"checksum percent-encoding 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
"checksum phf 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3dfb61232e34fcb633f43d12c58f83c1df82962dcdfa565a4e866ffc17dafe12"
"checksum phf_codegen 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "cbffee61585b0411840d3ece935cce9cb6321f01c45477d30066498cd5e1a815"
"checksum phf_generator 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "17367f0cc86f2d25802b2c26ee58a7b23faeccf78a396094c13dced0d0182526"
"checksum phf_shared 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c00cf8b9eafe68dde5e9eaa2cef8ee84a9336a47d566ec55ca16589633b65af7"
"checksum pin-project 0.4.23 (registry+https://github.com/rust-lang/crates.io-index)" = "ca4433fff2ae79342e497d9f8ee990d174071408f28f726d6d83af93e58e48aa"
"checksum pin-project-internal 0.4.23 (registry+https://github.com/rust-lang/crates.io-index)" = "2c0e815c3ee9a031fdf5af21c10aa17c573c9c6a566328d99e3936c34e36461f"
"checksum pin-project-lite 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "282adbf10f2698a7a77f8e983a74b2d18176c19a7fd32a45446139ae7b02b715"
"checksum pin-utils 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
"checksum pkg-config 0.3.18 (registry+https://github.com/rust-lang/crates.io-index)" = "d36492546b6af1463394d46f0c834346f31548646f6ba10849802c9c9a27ac33"
"checksum ppv-lite86 0.2.9 (registry+https://github.com/rust-lang/crates.io-index)" = "c36fa947111f5c62a733b652544dd0016a43ce89619538a8ef92724a6f501a20"
replacement in Cargo.lock at line 1804

[3.136105]→[3.49170:49325](∅→∅),[3.99656]→[3.136260:136414](∅→∅),[3.66945]→[3.136260:136414](∅→∅),[3.86202]→[3.136260:136414](∅→∅),[3.49325]→[3.136260:136414](∅→∅),[3.50971]→[3.136260:136414](∅→∅),[3.63865]→[3.136260:136414](∅→∅),[3.136260]→[3.136260:136414](∅→∅),[3.136414]→[3.70630:70783](∅→∅),[3.99810]→[3.136567:136716](∅→∅),[3.86356]→[3.136567:136716](∅→∅),[3.93149]→[3.136567:136716](∅→∅),[3.70783]→[3.136567:136716](∅→∅),[3.136567]→[3.136567:136716](∅→∅),[3.136716]→[3.63866:64015](∅→∅),[3.67095]→[3.99960:100408](∅→∅),[3.93299]→[3.99960:100408](∅→∅),[3.64015]→[3.99960:100408](∅→∅),[3.70933]→[3.99960:100408](∅→∅),[3.99960]→[3.99960:100408](∅→∅)

"checksum proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4d317f9caece796be1980837fd5cb3dfec5613ebdb04ad0956deea83ce168915"
"checksum quick-error 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9274b940887ce9addde99c4eee6b5c44cc494b182b97e73dc8ffdcb3397fd3f0"
"checksum quick-xml 0.13.3 (registry+https://github.com/rust-lang/crates.io-index)" = "22fcc48ecef4609b243e8c01ff4695d08ee0fc9d5bdbc54630e1a5fe8bb40953"
"checksum quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e920b65c65f10b2ae65c831a81a073a89edd28c7cce89475bff467ab4167a"
"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"

[3.136105]

[3.100408]

"checksum proc-macro-hack 0.5.18 (registry+https://github.com/rust-lang/crates.io-index)" = "99c605b9a0adc77b7211c6b1f722dcb613d68d66859a44f3d485a6da332b0598"
"checksum proc-macro-nested 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "eba180dafb9038b050a4c280019bbedf9f2467b61e5d892dcad585bb57aadc5a"
"checksum proc-macro2 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)" = "175c513d55719db99da20232b06cda8bab6b83ec2d04e3283edf0213c37c1a29"
"checksum quick-error 1.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
"checksum quick-xml 0.18.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3cc440ee4802a86e357165021e3e255a9143724da31db1e2ea540214c96a0f82"
"checksum quote 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37"
"checksum rand 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
"checksum rand_chacha 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
replacement in Cargo.lock at line 1813

[3.100560]→[3.100560:101015](∅→∅),[3.100560]→[3.100560:101015](∅→∅),[3.100560]→[3.100560:101015](∅→∅),[3.100560]→[3.100560:101015](∅→∅),[3.100560]→[3.100560:101015](∅→∅),[3.101015]→[3.49326:49480](∅→∅)

"checksum rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d0e7a549d590831370895ab7ba4ea0c1b6b011d106b5ff2da6eee112615e6dc0"
"checksum rand_hc 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7b40677c7be09ae76218dc623efbf7b18e34bced3f38883af07bb75630a21bc4"
"checksum rand_isaac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ded997c9d5f13925be2a6fd7e66bf1872597f759fd9dd93513dd7e92e5a5ee08"
"checksum rand_jitter 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b9ea758282efe12823e0d952ddb269d2e1897227e464919a554f2a03ef1b832"

[3.100560]

[3.64170]

"checksum rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"
"checksum rand_core 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
"checksum rand_hc 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
replacement in Cargo.lock at line 1817

[3.67246]→[3.71084:71235](∅→∅),[3.64320]→[3.71084:71235](∅→∅),[3.71084]→[3.71084:71235](∅→∅),[3.93601]→[3.101470:101626](∅→∅),[3.71235]→[3.101470:101626](∅→∅),[3.101470]→[3.101470:101626](∅→∅)

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

[3.64320]

[3.101626]

"checksum rand_pcg 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "16abd0c1b639e9eb4d7c50c0b8100b0d0f849be2349829c740fe8e6eb4816429"
replacement in Cargo.lock at line 1819

[3.101775]→[3.64321:64478](∅→∅),[3.101932]→[3.138837:138993](∅→∅),[3.67404]→[3.138837:138993](∅→∅),[3.87260]→[3.138837:138993](∅→∅),[3.93759]→[3.138837:138993](∅→∅),[3.64478]→[3.138837:138993](∅→∅),[3.71393]→[3.138837:138993](∅→∅),[3.138837]→[3.138837:138993](∅→∅),[3.138993]→[3.49481:49941](∅→∅),[3.49941]→[3.102237:102391](∅→∅),[3.64939]→[3.102237:102391](∅→∅),[3.139453]→[3.102237:102391](∅→∅),[3.102391]→[3.49942:50100](∅→∅),[3.102549]→[3.139765:139921](∅→∅),[3.67867]→[3.139765:139921](∅→∅),[3.87876]→[3.139765:139921](∅→∅),[3.94222]→[3.139765:139921](∅→∅),[3.50100]→[3.139765:139921](∅→∅),[3.65098]→[3.139765:139921](∅→∅),[3.71856]→[3.139765:139921](∅→∅),[3.139765]→[3.139765:139921](∅→∅),[3.139921]→[3.50101:50247](∅→∅)

"checksum redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)" = "12229c14a0f65c4f1cb046a3b52047cdd9da1f4b30f8a39c5063c8bae515e252"
"checksum redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7e891cfe48e9100a70a3b6eb652fef28920c117d366339687bd5576160db0f76"
"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"
"checksum remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3488ba1b9a2084d38645c4c08276a1752dcbf2c7130d74f1569681ad5d2799c5"
"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"
"checksum rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
"checksum ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "eb9e9b8cde282a9fe6a42dd4681319bfb63f121b8a8ee9439c6f4107e58a46f7"

[3.101775]

[3.102696]

"checksum redox_syscall 0.1.57 (registry+https://github.com/rust-lang/crates.io-index)" = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
"checksum regex 1.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "9c3780fcf44b193bc4d09f36d2a3c87b251da4a046c87795a0d35f4f927ad8e6"
"checksum regex-syntax 0.6.18 (registry+https://github.com/rust-lang/crates.io-index)" = "26412eb97c6b088a6997e05f69403a802a92d520de2f8e63c2b65f9e0f47c4e8"
"checksum remove_dir_all 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
"checksum resolv-conf 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "11834e137f3b14e309437a8276714eed3a80d1ef894869e510f2c0c0b98b9f4a"
"checksum rustc-demangle 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "4c691c0e608126e00913e33f0ccf3727d5fc84573623b8d65b2df340b5201783"
"checksum ryu 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
replacement in Cargo.lock at line 1827

[3.102843]→[3.71857:72009](∅→∅),[3.102995]→[3.140366:140519](∅→∅),[3.88472]→[3.140366:140519](∅→∅),[3.94375]→[3.140366:140519](∅→∅),[3.72009]→[3.140366:140519](∅→∅),[3.140366]→[3.140366:140519](∅→∅),[3.140519]→[3.50248:50574](∅→∅),[3.103322]→[3.140845:141150](∅→∅),[3.68194]→[3.140845:141150](∅→∅),[3.88799]→[3.140845:141150](∅→∅),[3.50574]→[3.140845:141150](∅→∅),[3.51447]→[3.140845:141150](∅→∅),[3.65572]→[3.140845:141150](∅→∅),[3.140845]→[3.140845:141150](∅→∅),[3.141150]→[3.50575:50880](∅→∅),[3.68500]→[3.72315:72469](∅→∅),[3.50880]→[3.72315:72469](∅→∅),[3.65878]→[3.72315:72469](∅→∅),[3.72315]→[3.72315:72469](∅→∅),[3.94835]→[3.103782:104077](∅→∅),[3.72469]→[3.103782:104077](∅→∅),[3.103782]→[3.103782:104077](∅→∅),[3.104077]→[3.50881:51182](∅→∅),[3.104378]→[3.142205:142357](∅→∅),[3.68802]→[3.142205:142357](∅→∅),[3.89855]→[3.142205:142357](∅→∅),[3.94990]→[3.142205:142357](∅→∅),[3.51182]→[3.142205:142357](∅→∅),[3.51912]→[3.142205:142357](∅→∅),[3.66343]→[3.142205:142357](∅→∅),[3.72624]→[3.142205:142357](∅→∅),[3.142205]→[3.142205:142357](∅→∅)

"checksum schannel 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "f2f6abf258d99c3c1c5c2131d99d064e94b7b3dd5f416483057f308fea253339"
"checksum scopeguard 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "94258f53601af11e6a49f722422f6e3425c52b06245a5cf9bc09908b174f5e27"
"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"
"checksum semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
"checksum semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
"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"
"checksum siphasher 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "0b8de496cf83d4ed58b6be86c3a275b8602f6ffe98d3024a869e124147a9a3ac"

[3.102843]

[3.104379]

"checksum schannel 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)" = "8f05ba609c234e60bee0d547fe94a4c7e9da733d1c962cf6e59efa4cd9c8bc75"
"checksum security-framework 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)" = "64808902d7d99f78eaddd2b4e2509713babc3dc3c85ad6f4c447680f3c01e535"
"checksum security-framework-sys 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "17bf11d99252f512695eb468de5516e5cf75455521e69dfe343f3b74e4748405"
"checksum serde 1.0.115 (registry+https://github.com/rust-lang/crates.io-index)" = "e54c9a88f2da7238af84b5101443f0c0d0a3bbdc455e34a5c9497b1903ed55d5"
"checksum serde_derive 1.0.115 (registry+https://github.com/rust-lang/crates.io-index)" = "609feed1d0a73cc36a0182a840a9b37b4a82f0b1150369f0536a9e3f2a31dc48"
"checksum serde_json 1.0.57 (registry+https://github.com/rust-lang/crates.io-index)" = "164eacbdb13512ec2745fb09d51fd5b22b0d65ed294a1dcf7285a360c80a675c"
"checksum sha-1 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f7d94d0bede923b3cea61f3f1ff57ff8cdfd77b400fb8f9998949e0cf04163df"
"checksum sha2 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a256f46ea78a0c0d9ff00077504903ac881a1dafdc20da66545699e7776b3e69"
"checksum sha3 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dd26bc0e7a2e3a7c959bc494caf58b72ee0c71d67704e9520f736ca7e4853ecf"
"checksum signal-hook-registry 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a3e12110bc539e657a646068aaf5eb5b63af9d0c1f7b29c97113fad80e15f035"
"checksum siphasher 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "fa8f3741c7372e75519bd9346068370c9cdaabcc1f9599cbcf2a2719352286b7"
replacement in Cargo.lock at line 1839

[3.104526]→[3.51183:51484](∅→∅),[3.51484]→[3.142805:142966](∅→∅),[3.66646]→[3.142805:142966](∅→∅),[3.142805]→[3.142805:142966](∅→∅),[3.142966]→[3.51485:51634](∅→∅),[3.104827]→[3.143115:143595](∅→∅),[3.90304]→[3.143115:143595](∅→∅),[3.51634]→[3.143115:143595](∅→∅),[3.66796]→[3.143115:143595](∅→∅),[3.143115]→[3.143115:143595](∅→∅)

"checksum smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "c4488ae950c49d403731982257768f48fada354a5203fe81f9bb6f43ca9002be"
"checksum socket2 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)" = "c4d11a52082057d87cb5caa31ad812f4504b97ab44732cd8359df2e9ff9f48e7"
"checksum stable_deref_trait 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "dba1a27d3efae4351c8051072d619e3ade2820635c3958d826bfea39d59b54c8"
"checksum string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b639411d0b9c738748b5397d5ceba08e648f4f1992231aa859af1a017f31f60b"
"checksum string_cache 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "25d70109977172b127fe834e5449e5ab1740b9ba49fa18a2020f509174f25423"
"checksum string_cache_codegen 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1eea1eee654ef80933142157fdad9dd8bc43cf7c74e999e369263496f04ff4da"
"checksum string_cache_shared 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b1884d1bc09741d466d9b14e6d37ac89d6909cbcac41dd9ae982d4d063bbedfc"

[3.104526]

[3.66797]

"checksum smallvec 1.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "fbee7696b84bbf3d89a1c2eccff0850e3047ed46bfcd2e92c29a2d074d57e252"
"checksum socket2 0.3.12 (registry+https://github.com/rust-lang/crates.io-index)" = "03088793f677dce356f3ccc2edb1b314ad191ab702a5de3faf49304f7e104918"
"checksum string_cache 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2940c75beb4e3bf3a494cef919a747a2cb81e52571e212bfbd185074add7208a"
"checksum string_cache_codegen 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f24c8e5e19d22a726626f1a5e16fe15b132dcf21d10177fa5a45ce7962996b97"
replacement in Cargo.lock at line 1845

[3.105126]→[3.143893:144041](∅→∅),[3.90454]→[3.143893:144041](∅→∅),[3.143893]→[3.143893:144041](∅→∅),[3.144041]→[3.51635:51783](∅→∅),[3.105275]→[3.144189:144338](∅→∅),[3.69101]→[3.144189:144338](∅→∅),[3.90603]→[3.144189:144338](∅→∅),[3.35166]→[3.144189:144338](∅→∅),[3.95441]→[3.144189:144338](∅→∅),[3.51783]→[3.144189:144338](∅→∅),[3.52061]→[3.144189:144338](∅→∅),[3.67095]→[3.144189:144338](∅→∅),[3.73075]→[3.144189:144338](∅→∅),[3.144189]→[3.144189:144338](∅→∅),[3.144338]→[3.51784:52091](∅→∅)

"checksum syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)" = "d3b891b9015c88c576343b9b3e41c2c11a51c219ef067b264bd9c8aa9b441dad"
"checksum syn 0.15.30 (registry+https://github.com/rust-lang/crates.io-index)" = "66c8865bf5a7cbb662d8b011950060b3c8743dca141b054bf7195b20d314d8e2"
"checksum synom 0.11.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a393066ed9010ebaed60b9eafa373d4b1baac186dd7e008555b0f702b51945b6"
"checksum synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73687139bf99285483c96ac0add482c3776528beac1d97d444f6e91f203a2015"
"checksum tempfile 3.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "b86c784c88d98c801132806dadd3819ed29d8600836c4088e855cdf3e178ed8a"

[3.105126]

[3.105583]

"checksum syn 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)" = "963f7d3cc59b59b9325165add223142bbf1df27655d07789f109896d353d8350"
"checksum synstructure 0.12.4 (registry+https://github.com/rust-lang/crates.io-index)" = "b834f2d66f734cb897113e34aaff2f1ab4719ca946f9a7358dba8f8064148701"
"checksum tempfile 3.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e24d9338a0a5be79593e2fa15a648add6138caa803e2d5bc782c371732ca9"
replacement in Cargo.lock at line 1849

[3.105733]→[3.52092:52394](∅→∅)

"checksum termcolor 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4096add70612622289f2fdcdbd5086dc81c1e2675e6ae58d6c4f62a16c6d7f2f"
"checksum termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "689a3bdfaab439fd92bc87df5c4c78417d3cbe537487274e9b0b2dce76e92096"

[3.105733]

[3.67706]

"checksum termcolor 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb6bfa289a4d7c5766392812c0a1f4c1ba45afa1ad47803c11e1f407d846d75f"
replacement in Cargo.lock at line 1851

[3.105886]→[3.145249:145404](∅→∅),[3.69404]→[3.145249:145404](∅→∅),[3.91214]→[3.145249:145404](∅→∅),[3.95746]→[3.145249:145404](∅→∅),[3.67858]→[3.145249:145404](∅→∅),[3.73380]→[3.145249:145404](∅→∅),[3.145249]→[3.145249:145404](∅→∅),[3.145404]→[3.105887:106035](∅→∅),[3.106035]→[3.52395:52544](∅→∅),[3.106184]→[3.145701:146011](∅→∅),[3.69554]→[3.145701:146011](∅→∅),[3.91512]→[3.145701:146011](∅→∅),[3.95896]→[3.145701:146011](∅→∅),[3.52544]→[3.145701:146011](∅→∅),[3.52362]→[3.145701:146011](∅→∅),[3.68160]→[3.145701:146011](∅→∅),[3.73530]→[3.145701:146011](∅→∅),[3.145701]→[3.145701:146011](∅→∅),[3.146011]→[3.68161:68481](∅→∅),[3.69875]→[3.73851:74310](∅→∅),[3.68481]→[3.73851:74310](∅→∅),[3.73851]→[3.73851:74310](∅→∅),[3.96676]→[3.106964:107119](∅→∅),[3.74310]→[3.106964:107119](∅→∅),[3.106964]→[3.106964:107119](∅→∅),[3.107119]→[3.52545:52698](∅→∅),[3.70029]→[3.107272:107424](∅→∅),[3.96830]→[3.107272:107424](∅→∅),[3.52698]→[3.107272:107424](∅→∅),[3.52516]→[3.107272:107424](∅→∅),[3.68635]→[3.107272:107424](∅→∅),[3.74464]→[3.107272:107424](∅→∅),[3.107272]→[3.107272:107424](∅→∅),[3.107424]→[3.52699:53014](∅→∅),[3.53014]→[3.107739:107891](∅→∅),[3.68951]→[3.107739:107891](∅→∅),[3.107739]→[3.107739:107891](∅→∅),[3.107891]→[3.53015:53174](∅→∅),[3.53174]→[3.108050:108507](∅→∅),[3.69111]→[3.108050:108507](∅→∅),[3.74785]→[3.108050:108507](∅→∅),[3.108050]→[3.108050:108507](∅→∅),[3.108507]→[3.53175:53322](∅→∅),[3.70339]→[3.108654:108974](∅→∅),[3.97140]→[3.108654:108974](∅→∅),[3.53322]→[3.108654:108974](∅→∅),[3.69259]→[3.108654:108974](∅→∅),[3.74933]→[3.108654:108974](∅→∅),[3.108654]→[3.108654:108974](∅→∅),[3.108974]→[3.148800:148951](∅→∅),[3.93987]→[3.148800:148951](∅→∅),[3.148800]→[3.148800:148951](∅→∅),[3.148951]→[3.108975:109126](∅→∅),[3.109126]→[3.149102:149253](∅→∅),[3.94139]→[3.149102:149253](∅→∅),[3.149102]→[3.149102:149253](∅→∅),[3.149253]→[3.109127:109278](∅→∅)

"checksum thread_local 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c6b53e329000edc2b34dbe8545fd20e55a333362d0a321909685a19bd28c3f1b"
"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"
"checksum tokio-channel 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "530d0fb87416dd531600f7cccc438bb35c5b91883065c9e6dca7cdecee991cfa"
"checksum tokio-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5c501eceaf96f0e1793cf26beb63da3d11c738c4a943fdf3746d81d64684c39f"
"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"
"checksum tokio-signal 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "dd6dc5276ea05ce379a16de90083ec80836440d5ef8a6a39545a3207373b8296"
"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"
"checksum tokio-udp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "66268575b80f4a4a710ef83d087fdfeeabdce9b74c797535fbac18a2cb906e92"
"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"
"checksum try-lock 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e604eb7b43c06650e854be16a2a03155743d3752dd1c943f6829e26b7a36e382"
"checksum try_from 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "283d3b89e1368717881a9d51dad843cc435380d8109c9e47d38780a324698d8b"
"checksum typenum 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "612d636f949607bdf9b123b4a6f6d966dedf3ff669f7f045890d3a4a73948169"
"checksum ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "535c204ee4d8434478593480b8f86ab45ec9aae0e83c568ca81abf0fd0e88f86"

[3.67858]

[3.149404]

"checksum thiserror 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)" = "7dfdd070ccd8ccb78f4ad66bf1982dc37f620ef696c6b5028fe2ed83dd3d0d08"
"checksum thiserror-impl 1.0.20 (registry+https://github.com/rust-lang/crates.io-index)" = "bd80fc12f73063ac132ac92aceea36734f04a1d93c1240c6944e23a3b8841793"
"checksum thread_local 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "d40c6d1b69745a6ec6fb1ca717914848da4b44ae29d9b3080cbee91d72a69b14"
"checksum time 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)" = "6db9e6914ab8b1ae1c260a4ae7a49b6c5611b40328a735b21862567685e73255"
"checksum tinyvec 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "238ce071d267c5710f9d31451efec16c5ee22de34df17cc05e56cbc92e967117"
"checksum tokio 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)" = "5d34ca54d84bf2b5b4d7d31e901a8464f7b60ac145a284fba25ceb801f2ddccd"
"checksum tokio-macros 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "f0c3acc6aa564495a0f2e1d59fab677cd7f81a19994cfc7f3ad0e64301560389"
"checksum tokio-tls 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9a70f4fcd7b3b24fb194f837560168208f669ca8cb70d0c4b862944452396343"
"checksum tokio-util 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "571da51182ec208780505a32528fc5512a8fe1443ab960b3f2f3ef093cd16930"
"checksum tokio-util 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "be8242891f2b6cbef26a2d7e8605133c2c554cd35b3e4948ea892d6d68436499"
"checksum tokio-xmpp 2.0.0 (git+https://gitlab.com/xmpp-rs/xmpp-rs)" = "<none>"
"checksum toml 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)" = "ffc92d160b1eef40665be3a05630d003936a3bc7da7421277846c2613e92c71a"
"checksum tower-service 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e987b6bf443f4b5b3b6f38704195592cca41c5bb7aedd3c3693c7081f8289860"
"checksum tracing 0.1.19 (registry+https://github.com/rust-lang/crates.io-index)" = "6d79ca061b032d6ce30c660fded31189ca0b9922bf483cd70759f13a2d86786c"
"checksum tracing-core 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "4f0e00789804e99b20f12bc7003ca416309d28a6f495d6af58d1e2c2842461b5"
"checksum trust-dns-proto 0.19.5 (registry+https://github.com/rust-lang/crates.io-index)" = "cdd7061ba6f4d4d9721afedffbfd403f20f39a4301fee1b70d6fcd09cca69f28"
"checksum trust-dns-resolver 0.19.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0f23cdfdc3d8300b3c50c9e84302d3bd6d860fb9529af84ace6cf9665f181b77"
"checksum try-lock 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642"
"checksum typenum 1.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "373c8a200f9e67a0c95e62a4f52fbf80c23b4381c05a17845531982fa99e6b33"
replacement in Cargo.lock at line 1871

[3.149559]→[3.109279:109443](∅→∅),[3.109443]→[3.149723:150187](∅→∅),[3.94456]→[3.149723:150187](∅→∅),[3.149723]→[3.149723:150187](∅→∅),[3.97295]→[3.109444:109590](∅→∅),[3.150187]→[3.109444:109590](∅→∅)

"checksum unicode-normalization 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "141339a08b982d942be2ca06ff8b076563cbe223d1befd5450716790d44e2426"
"checksum unicode-width 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "882386231c45df4700b275c7ff55b6f3698780a650026380e72dabe76fa46526"
"checksum unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "8c1f860d7d29cf02cb2f3f359fd35991af3d30bac52c57d265a3c461074cb4dc"
"checksum unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc"
"checksum url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dd4e7c0d531266369519a4aa4f399d748bd37043b00bde1e4ff1f60a120b355a"

[3.149559]

[3.109590]

"checksum unicode-normalization 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "6fb19cf769fa8c6a80a162df694621ebeb4dafb606470b2b2fce0be40a98a977"
"checksum unicode-segmentation 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e83e153d1053cbb5a118eeff7fd5be06ed99153f00dbcd8ae310c5fb2b22edc0"
"checksum unicode-width 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"
"checksum unicode-xid 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"
"checksum url 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "829d4a8476c35c9bf0bbce5a3b23f4106f79728039b726d292bb93bc106787cb"
replacement in Cargo.lock at line 1877

[3.109738]→[3.53323:53477](∅→∅),[3.109892]→[3.150635:150933](∅→∅),[3.95059]→[3.150635:150933](∅→∅),[3.53477]→[3.150635:150933](∅→∅),[3.69414]→[3.150635:150933](∅→∅),[3.150635]→[3.150635:150933](∅→∅),[3.95363]→[3.150933:151233](∅→∅),[3.97443]→[3.150933:151233](∅→∅),[3.150933]→[3.150933:151233](∅→∅)

"checksum utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "796f7e48bef87609f7ade7e06495a87d5cd06c7866e6a5cbfceffc558a243737"
"checksum vcpkg 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "def296d3eb3b12371b2c7d0e83bfe1403e4db2d7a0bba324a12b21c4ee13143d"
"checksum vec_map 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "05c78687fb1a80548ae3250346c3db86a80a7cdd77bda190189f2d0a0987c81a"
"checksum want 0.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "797464475f30ddb8830cc529aaaae648d581f99e2036a928877dfde027ddf6b3"
"checksum widestring 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7157704c2e12e3d2189c507b7482c52820a16dfa4465ba91add92f266667cadb"

[3.109738]

[3.151233]

"checksum vcpkg 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)" = "6454029bf181f092ad1b853286f23e2c507d8e8194d01d92da4a55c274a5508c"
"checksum vec_map 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
"checksum want 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
"checksum wasi 0.10.0+wasi-snapshot-preview1 (registry+https://github.com/rust-lang/crates.io-index)" = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
"checksum wasi 0.9.0+wasi-snapshot-preview1 (registry+https://github.com/rust-lang/crates.io-index)" = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
"checksum widestring 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a763e303c0e0f23b0da40888724762e802a8ffefbc22de4127ef42493c2ea68c"
replacement in Cargo.lock at line 1884

[3.151382]→[3.69415:69564](∅→∅)

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

[3.151382]

[3.151531]

"checksum winapi 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
replacement in Cargo.lock at line 1887

[3.151855]→[3.110043:110197](∅→∅)

"checksum winapi-util 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7168bab6e1daee33b4557efd0e95d5ca70a03706d39fa5f3fe7a236f584b03c9"

[3.151855]

[3.152009]

"checksum winapi-util 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
replacement in Cargo.lock at line 1889

[3.152180]→[3.152180:152630](∅→∅),[3.152180]→[3.152180:152630](∅→∅),[3.152180]→[3.152180:152630](∅→∅)

"checksum wincolor 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "561ed901ae465d6185fa7864d63fbd5720d0ef718366c9a4dc83cf6170d7e9ba"
"checksum winreg 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a27a759395c1195c4cc5cda607ef6f8f6498f64e78f7900f5de0a127a424704a"
"checksum winutil 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7daf138b6b14196e3830a588acf1e86966c694d3e8fb026fb105b8b5dca07e6e"

[3.152180]

[3.152630]

"checksum winreg 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b2986deb581c4fe11b621998a5e53361efe6b48a151178d0cd9eeffa4dc6acc9"
replacement in Cargo.lock at line 1891

[3.152783]→[3.110198:110506](∅→∅),[3.110506]→[3.69565:69721](∅→∅)

"checksum xml5ever 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)" = "32cd7ebf0203c620906230ce22caa5df0b603c32b6fef72a275a48f6a2ae64b9"
"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"

[3.152783]

"checksum xml5ever 0.16.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0b1b52e6e8614d4a58b8e70cf51ec0cc21b256ad8206708bcff8139b5bbd6a59"
"checksum xmpp-parsers 0.17.0 (git+https://gitlab.com/xmpp-rs/xmpp-rs)" = "<none>"