O01eg/sendxmppd-rs - Change 2THKW66MYPEDGPVSVX243DJIHE6RUXYSAANFPTEV5KLS3XHX4MEQC

Ignore .orig files

Created by O01eg on April 14, 2019

2THKW66MYPEDGPVSVX243DJIHE6RUXYSAANFPTEV5KLS3XHX4MEQC

Dependencies

In channels

main

Change contents

Replacement in src/xmpp/xmpp_connection.rs at line 0 [3.21]

∅:D[3.21] → [2.0:29189]

use tokio_xmpp::{Client, Event, Packet};
use tokio::prelude::future::{self, Either};
use tokio::prelude::stream;
use tokio::prelude::{Future, Stream};
use std::collections::{HashMap, VecDeque};
use super::XmppCommand;
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// ids counter
    counter: usize,
    /// map from id of adding item to roster and jid of item
    pending_add_roster_ids: HashMap<String, xmpp_parsers::Jid>,
    /// stanzas to send
    send_queue: VecDeque<minidom::Element>,
    /// outgoing mailbox
    outgoing_mailbox: HashMap<xmpp_parsers::Jid, Vec<String>>,
    /// muc id to muc jid
    mucs: HashMap<String, xmpp_parsers::Jid>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
struct XmppElementProcessor {
    incoming: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element>,
}
impl XmppElementProcessor {
    fn new() -> XmppElementProcessor {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {:#?}", e);
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        XmppElementProcessor { incoming }
    }
}
pub struct MaybeXmppConnection {
    account: std::rc::Rc<config::Account>,
    state: Option<XmppState>,
}
impl From<XmppConnection> for MaybeXmppConnection {
    fn from(from: XmppConnection) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from.account,
            state: Some(from.state),
        }
    }
}
impl From<config::Account> for MaybeXmppConnection {
    fn from(from: config::Account) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: std::rc::Rc::new(from),
            state: None,
        }
    }
}
impl From<std::rc::Rc<config::Account>> for MaybeXmppConnection {
    fn from(from: std::rc::Rc<config::Account>) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from,
            state: None,
        }
    }
}
impl MaybeXmppConnection {
    /// connects if nothing connected
    /// don't connect only if stop_future resolved
    pub fn connect<F>(
        self,
        stop_future: F,
    ) -> impl Future<Item = XmppConnection, Error = failure::Error>
    where
        F: future::Future + Clone + 'static,
        <F as hyper::rt::Future>::Error: Into<failure::Error> + Send,
    {
        info!("xmpp connection...");
        let MaybeXmppConnection { account, state } = self;
        if let Some(state) = state {
            Box::new(future::ok(XmppConnection { account, state }))
                as Box<dyn Future<Item = _, Error = _>>
        } else {
            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");
                            let stop_future2 = stop_future.clone();
                            let stop_future3 = stop_future.clone();
                            let stop_future4 = stop_future.clone();
                            // 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"))
                        }
                    }),
            )
        }
    }
}
impl XmppConnection {
    /// base XMPP processing
    /// Returns false on error to disconnect
    fn xmpp_processing(&mut self, event: &Event) -> bool {
        match event {
            Event::Stanza(stanza) => {
                let processors = XmppElementProcessor::new();
                processors.incoming.process(self, stanza.clone())
            }
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        use std::convert::TryInto;
        if let Some((_, jid)) = self.state.data.pending_add_roster_ids.remove_entry(&iq.id) {
            if let xmpp_parsers::iq::IqType::Result(None) = iq.payload {
                if self.state.data.roster.contains_key(&jid) {
                    info!("Jid {} updated to roster", jid);
                } else {
                    info!("Jid {} added in roster", jid);
                    self.state.data.roster.insert(
                        jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                self.process_jid(&jid);
            } else {
                warn!(
                    "Wrong payload when adding {} to roster: {:?}",
                    jid, iq.payload
                );
            }
        }
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                if let Some(roster) =
                    element.try_into().ok() as Option<xmpp_parsers::roster::Roster>
                {
                    for i in roster.items {
                        if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                            info!("Update {} in roster", i.jid);
                            rdata.0 = i.subscription;
                            rdata.1 = i.ask;
                        } else {
                            info!("Add {} to roster", i.jid);
                            self.state
                                .data
                                .roster
                                .insert(i.jid.clone(), (i.subscription, i.ask));
                        }
                        self.process_jid(&i.jid);
                    }
                }
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                if let Some(_ping) = element.try_into().ok() as Option<xmpp_parsers::ping::Ping> {
                    let pong = stanzas::make_pong(&iq.id, self.state.client.jid.clone(), iq.from);
                    self.state.data.send_queue.push_back(pong);
                }
            }
            _ => (), // ignore
        }
        true
    }
    /// 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,
        stop_future: F,
    ) -> impl Future<
        Item = (Self, Result<Either<F, T>, E>),
        Error = (std::rc::Rc<config::Account>, Result<Either<F, T>, E>),
    >
    where
        F: Future<Item = T, Error = E> + 'static,
        S: FnMut(&mut Self, Event) -> Result<bool, ()> + 'static,
        T: 'static,
        E: 'static,
    {
        future::loop_fn(
            (self, stop_future, stop_condition),
            |(xmpp, stop_future, mut stop_condition)| {
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {:?}", send_element);
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                Err(Either::A((e, b))) => {
                                    warn!("XMPP sending error: {}", e);
                                    Box::new(future::err((account, Ok(Either::A(b)))))
                                }
                                Err(Either::B((e, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Err(e),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Err(e)))
                                    }
                                })),
                            }),
                    ) as Box<dyn Future<Item = _, Error = _>>
                } else {
                    Box::new(
                        client
                            .into_future()
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A(((event, client), b))) => {
                                    if let Some(event) = event {
                                        let mut xmpp = XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        };
                                        if xmpp.xmpp_processing(&event) {
                                            match stop_condition(&mut xmpp, event) {
                                                Ok(true) => future::ok(future::Loop::Break((
                                                    xmpp,
                                                    Ok(Either::A(b)),
                                                ))),
                                                Ok(false) => future::ok(future::Loop::Continue((
                                                    xmpp,
                                                    b,
                                                    stop_condition,
                                                ))),
                                                Err(_e) => {
                                                    future::err((xmpp.account, Ok(Either::A(b))))
                                                }
                                            }
                                        } else {
                                            future::err((xmpp.account, Ok(Either::A(b))))
                                        }
                                    } else {
                                        future::err((account, Ok(Either::A(b))))
                                    }
                                }
                                Ok(Either::B((t, a))) => {
                                    if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Ok(Either::B(t)),
                                        )))
                                    } else {
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                }
                                Err(Either::A((e, b))) => {
                                    warn!("XMPP error: {}", e.0);
                                    future::err((account, Ok(Either::A(b))))
                                }
                                Err(Either::B((e, a))) => {
                                    if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Err(e),
                                        )))
                                    } else {
                                        future::err((account, Err(e)))
                                    }
                                }
                            }),
                    )
                }
            },
        )
    }
    /// get connection and wait for online status and set presence
    /// returns error if something went wrong and xmpp connection is broken
    fn online(&mut self, event: Event) -> Result<bool, ()> {
        match event {
            Event::Online => {
                info!("Online!");
                Ok(true)
            }
            Event::Stanza(s) => {
                warn!("Stanza before online: {:?}", s);
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                Err(())
            }
        }
    }
    fn process_initial_roster(&mut self, event: Event, id_init_roster: &str) -> Result<bool, ()> {
        if let Event::Stanza(s) = event {
            use std::convert::TryInto;
            match s.try_into() as Result<xmpp_parsers::iq::Iq, _> {
                Ok(iq) => {
                    if iq.id == id_init_roster {
                        match iq.payload {
                            xmpp_parsers::iq::IqType::Error(_e) => {
                                error!("Get error instead of roster");
                                Err(())
                            }
                            xmpp_parsers::iq::IqType::Result(Some(result)) => {
                                match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                                    Ok(roster) => {
                                        self.state.data.roster.clear();
                                        info!("Got first roster:");
                                        for i in roster.items {
                                            info!(" >>> {:?}", i);
                                            self.state
                                                .data
                                                .roster
                                                .insert(i.jid, (i.subscription, i.ask));
                                        }
                                        Ok(true)
                                    }
                                    Err(e) => {
                                        error!("Cann't parse roster: {}", e);
                                        Err(())
                                    }
                                }
                            }
                            _ => {
                                error!("Unknown result of roster");
                                Err(())
                            }
                        }
                    } else {
                        Ok(false)
                    }
                }
                Err(_e) => Ok(false),
            }
        } else {
            error!("Wrong event while waiting roster");
            Err(())
        }
    }
    fn initial_roster<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: 'static,
    {
        let XmppConnection {
            account,
            state: XmppState { client, mut data },
        } = self;
        use tokio::prelude::Sink;
        data.counter += 1;
        let id_init_roster = format!("id_init_roster{}", data.counter);
        let get_roster = stanzas::make_get_roster(&id_init_roster);
        let account2 = account.clone();
        info!("Quering roster... {:?}", get_roster);
        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,
                }
                .processing(
                    move |conn, event| conn.process_initial_roster(event, &id_init_roster),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn self_presence<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,
    {
        let XmppConnection {
            account,
            state: XmppState { client, data },
        } = self;
        use tokio::prelude::Sink;
        let presence = stanzas::make_presence(&account);
        let account2 = account.clone();
        info!("Sending presence... {:?}", presence);
        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,
                }
                .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());
                    self.state
                        .data
                        .pending_add_roster_ids
                        .insert(id_add_roster, xmpp_to.clone());
                    info!("Adding jid to roster... {:?}", add_roster);
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    pub fn process_command(&mut self, cmd: XmppCommand) {
        info!("Got command");
        match cmd {
            XmppCommand::Chat { xmpp_to, message } => {
                self.state
                    .data
                    .outgoing_mailbox
                    .entry(xmpp_to.clone())
                    .or_default()
                    .push(message);
                self.process_jid(&xmpp_to);
            }
            XmppCommand::Chatroom { muc_id, message } => {
                if let Some(muc) = self.state.data.mucs.get(&muc_id) {
                    self.state
                        .data
                        .send_queue
                        .push_back(stanzas::make_muc_message(muc.clone(), message));
                } else {
                    error!("Not found MUC {}", muc_id);
                }
            }
            XmppCommand::Ping => {
                self.state.data.counter += 1;
                let id_ping = format!("id_ping{}", self.state.data.counter);
                let ping = stanzas::make_ping(&id_ping, self.state.client.jid.clone());
                self.state.data.send_queue.push_back(ping);
            }
        }
    }
    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... {:?}", muc_presence);
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,
    {
        let XmppConnection { account, state } = self;
        let account2 = account.clone();
        let account3 = account.clone();
        stream::iter_ok(account.chatrooms.clone())
            .fold(state, move |XmppState { client, mut data }, muc_jid| {
                data.counter += 1;
                let id_muc_presence = format!("id_muc_presence{}", data.counter);
                let muc_presence = stanzas::make_muc_presence(
                    &id_muc_presence,
                    account2.jid.clone(),
                    muc_jid.1.clone(),
                );
                info!("Sending muc presence... {:?}", muc_presence);
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}

[3.21]

use tokio_xmpp::{Client, Event, Packet};
use tokio::prelude::future::{self, Either};
use tokio::prelude::stream;
use tokio::prelude::{Future, Stream};
use std::collections::{HashMap, VecDeque};
use super::XmppCommand;
use super::stanzas;
use super::element_processor;
use crate::config;
#[derive(Default)]
struct XmppData {
    /// known roster data
    roster: HashMap<
        xmpp_parsers::Jid,
        (
            xmpp_parsers::roster::Subscription,
            xmpp_parsers::roster::Ask,
        ),
    >,
    /// ids counter
    counter: usize,
    /// map from id of adding item to roster and jid of item
    pending_add_roster_ids: HashMap<String, xmpp_parsers::Jid>,
    /// stanzas to send
    send_queue: VecDeque<minidom::Element>,
    /// outgoing mailbox
    outgoing_mailbox: HashMap<xmpp_parsers::Jid, Vec<String>>,
    /// muc id to muc jid
    mucs: HashMap<String, xmpp_parsers::Jid>,
}
struct XmppState {
    client: Client,
    data: XmppData,
}
pub struct XmppConnection {
    account: std::rc::Rc<config::Account>,
    state: XmppState,
}
struct XmppElementProcessor {
    incoming: element_processor::Processor<XmppConnection, bool, xmpp_parsers::Element>,
}
impl XmppElementProcessor {
    fn new() -> XmppElementProcessor {
        let mut incoming = element_processor::Processor::new(&|_, e| {
            warn!("Unknown stanza {:#?}", e);
            true
        });
        incoming.register(&XmppConnection::incoming_iq_processing);
        XmppElementProcessor { incoming }
    }
}
pub struct MaybeXmppConnection {
    account: std::rc::Rc<config::Account>,
    state: Option<XmppState>,
}
impl From<XmppConnection> for MaybeXmppConnection {
    fn from(from: XmppConnection) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from.account,
            state: Some(from.state),
        }
    }
}
impl From<config::Account> for MaybeXmppConnection {
    fn from(from: config::Account) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: std::rc::Rc::new(from),
            state: None,
        }
    }
}
impl From<std::rc::Rc<config::Account>> for MaybeXmppConnection {
    fn from(from: std::rc::Rc<config::Account>) -> MaybeXmppConnection {
        MaybeXmppConnection {
            account: from,
            state: None,
        }
    }
}
impl MaybeXmppConnection {
    /// connects if nothing connected
    /// don't connect only if stop_future resolved
    pub fn connect<F>(
        self,
        stop_future: F,
    ) -> impl Future<Item = XmppConnection, Error = failure::Error>
    where
        F: future::Future + Clone + 'static,
        <F as hyper::rt::Future>::Error: Into<failure::Error> + Send,
    {
        info!("xmpp connection...");
        let MaybeXmppConnection { account, state } = self;
        if let Some(state) = state {
            Box::new(future::ok(XmppConnection { account, state }))
                as Box<dyn Future<Item = _, Error = _>>
        } else {
            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");
                            let stop_future2 = stop_future.clone();
                            let stop_future3 = stop_future.clone();
                            let stop_future4 = stop_future.clone();
                            // 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"))
                        }
                    }),
            )
        }
    }
}
impl XmppConnection {
    /// base XMPP processing
    /// Returns false on error to disconnect
    fn xmpp_processing(&mut self, event: &Event) -> bool {
        match event {
            Event::Stanza(stanza) => {
                let processors = XmppElementProcessor::new();
                processors.incoming.process(self, stanza.clone())
            }
            Event::Online => true,
            e => {
                warn!("Unexpected event {:?}", e);
                false
            }
        }
    }
    fn incoming_iq_processing(&mut self, iq: xmpp_parsers::iq::Iq) -> bool {
        use std::convert::TryInto;
        if let Some((_, jid)) = self.state.data.pending_add_roster_ids.remove_entry(&iq.id) {
            if let xmpp_parsers::iq::IqType::Result(None) = iq.payload {
                if self.state.data.roster.contains_key(&jid) {
                    info!("Jid {} updated to roster", jid);
                } else {
                    info!("Jid {} added in roster", jid);
                    self.state.data.roster.insert(
                        jid.clone(),
                        (
                            xmpp_parsers::roster::Subscription::None,
                            xmpp_parsers::roster::Ask::None,
                        ),
                    );
                }
                self.process_jid(&jid);
            } else {
                warn!(
                    "Wrong payload when adding {} to roster: {:?}",
                    jid, iq.payload
                );
            }
        }
        match iq.payload {
            xmpp_parsers::iq::IqType::Set(element) => {
                if let Some(roster) =
                    element.try_into().ok() as Option<xmpp_parsers::roster::Roster>
                {
                    for i in roster.items {
                        if let Some(ref mut rdata) = self.state.data.roster.get_mut(&i.jid) {
                            info!("Update {} in roster", i.jid);
                            rdata.0 = i.subscription;
                            rdata.1 = i.ask;
                        } else {
                            info!("Add {} to roster", i.jid);
                            self.state
                                .data
                                .roster
                                .insert(i.jid.clone(), (i.subscription, i.ask));
                        }
                        self.process_jid(&i.jid);
                    }
                }
            }
            xmpp_parsers::iq::IqType::Error(e) => {
                error!("iq error: {:?}", e);
                return false;
            }
            xmpp_parsers::iq::IqType::Get(element) => {
                if let Some(_ping) = element.try_into().ok() as Option<xmpp_parsers::ping::Ping> {
                    let pong = stanzas::make_pong(&iq.id, self.state.client.jid.clone(), iq.from);
                    self.state.data.send_queue.push_back(pong);
                }
            }
            _ => (), // ignore
        }
        true
    }
    /// 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,
        stop_future: F,
    ) -> impl Future<
        Item = (Self, Result<Either<F, T>, E>),
        Error = (std::rc::Rc<config::Account>, Result<Either<F, T>, E>),
    >
    where
        F: Future<Item = T, Error = E> + 'static,
        S: FnMut(&mut Self, Event) -> Result<bool, ()> + 'static,
        T: 'static,
        E: 'static,
    {
        future::loop_fn(
            (self, stop_future, stop_condition),
            |(xmpp, stop_future, mut stop_condition)| {
                let XmppConnection {
                    state: XmppState { client, mut data },
                    account,
                } = xmpp;
                if let Some(send_element) = data.send_queue.pop_front() {
                    use tokio::prelude::Sink;
                    info!("Sending {:?}", send_element);
                    Box::new(
                        client
                            .send(Packet::Stanza(send_element))
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A((client, b))) => {
                                    Box::new(future::ok(future::Loop::Continue((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        b,
                                        stop_condition,
                                    ))))
                                        as Box<dyn Future<Item = _, Error = _>>
                                }
                                Ok(Either::B((t, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Ok(Either::B(t)),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                })),
                                Err(Either::A((e, b))) => {
                                    warn!("XMPP sending error: {}", e);
                                    Box::new(future::err((account, Ok(Either::A(b)))))
                                }
                                Err(Either::B((e, a))) => Box::new(a.then(|r| match r {
                                    Ok(client) => future::ok(future::Loop::Break((
                                        XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        },
                                        Err(e),
                                    ))),
                                    Err(se) => {
                                        warn!("XMPP sending error: {}", se);
                                        future::err((account, Err(e)))
                                    }
                                })),
                            }),
                    ) as Box<dyn Future<Item = _, Error = _>>
                } else {
                    Box::new(
                        client
                            .into_future()
                            .select2(stop_future)
                            .then(move |r| match r {
                                Ok(Either::A(((event, client), b))) => {
                                    if let Some(event) = event {
                                        let mut xmpp = XmppConnection {
                                            state: XmppState { client, data },
                                            account,
                                        };
                                        if xmpp.xmpp_processing(&event) {
                                            match stop_condition(&mut xmpp, event) {
                                                Ok(true) => future::ok(future::Loop::Break((
                                                    xmpp,
                                                    Ok(Either::A(b)),
                                                ))),
                                                Ok(false) => future::ok(future::Loop::Continue((
                                                    xmpp,
                                                    b,
                                                    stop_condition,
                                                ))),
                                                Err(_e) => {
                                                    future::err((xmpp.account, Ok(Either::A(b))))
                                                }
                                            }
                                        } else {
                                            future::err((xmpp.account, Ok(Either::A(b))))
                                        }
                                    } else {
                                        future::err((account, Ok(Either::A(b))))
                                    }
                                }
                                Ok(Either::B((t, a))) => {
                                    if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Ok(Either::B(t)),
                                        )))
                                    } else {
                                        future::err((account, Ok(Either::B(t))))
                                    }
                                }
                                Err(Either::A((e, b))) => {
                                    warn!("XMPP error: {}", e.0);
                                    future::err((account, Ok(Either::A(b))))
                                }
                                Err(Either::B((e, a))) => {
                                    if let Some(client) = a.into_inner() {
                                        future::ok(future::Loop::Break((
                                            XmppConnection {
                                                state: XmppState { client, data },
                                                account,
                                            },
                                            Err(e),
                                        )))
                                    } else {
                                        future::err((account, Err(e)))
                                    }
                                }
                            }),
                    )
                }
            },
        )
    }
    /// get connection and wait for online status and set presence
    /// returns error if something went wrong and xmpp connection is broken
    fn online(&mut self, event: Event) -> Result<bool, ()> {
        match event {
            Event::Online => {
                info!("Online!");
                Ok(true)
            }
            Event::Stanza(s) => {
                warn!("Stanza before online: {:?}", s);
                Ok(false)
            }
            _ => {
                error!("Disconnected while online");
                Err(())
            }
        }
    }
    fn process_initial_roster(&mut self, event: Event, id_init_roster: &str) -> Result<bool, ()> {
        if let Event::Stanza(s) = event {
            use std::convert::TryInto;
            match s.try_into() as Result<xmpp_parsers::iq::Iq, _> {
                Ok(iq) => {
                    if iq.id == id_init_roster {
                        match iq.payload {
                            xmpp_parsers::iq::IqType::Error(_e) => {
                                error!("Get error instead of roster");
                                Err(())
                            }
                            xmpp_parsers::iq::IqType::Result(Some(result)) => {
                                match result.try_into() as Result<xmpp_parsers::roster::Roster, _> {
                                    Ok(roster) => {
                                        self.state.data.roster.clear();
                                        info!("Got first roster:");
                                        for i in roster.items {
                                            info!(" >>> {:?}", i);
                                            self.state
                                                .data
                                                .roster
                                                .insert(i.jid, (i.subscription, i.ask));
                                        }
                                        Ok(true)
                                    }
                                    Err(e) => {
                                        error!("Cann't parse roster: {}", e);
                                        Err(())
                                    }
                                }
                            }
                            _ => {
                                error!("Unknown result of roster");
                                Err(())
                            }
                        }
                    } else {
                        Ok(false)
                    }
                }
                Err(_e) => Ok(false),
            }
        } else {
            error!("Wrong event while waiting roster");
            Err(())
        }
    }
    fn initial_roster<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: 'static,
    {
        let XmppConnection {
            account,
            state: XmppState { client, mut data },
        } = self;
        use tokio::prelude::Sink;
        data.counter += 1;
        let id_init_roster = format!("id_init_roster{}", data.counter);
        let get_roster = stanzas::make_get_roster(&id_init_roster);
        let account2 = account.clone();
        info!("Quering roster... {:?}", get_roster);
        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,
                }
                .processing(
                    move |conn, event| conn.process_initial_roster(event, &id_init_roster),
                    stop_future,
                )
                .map_err(|(account, _)| account)
                .and_then(|(conn, r)| match r {
                    Ok(Either::A(_)) => future::ok(conn),
                    Ok(Either::B(_)) => future::err(conn.account),
                    Err(_e) => future::err(conn.account),
                })
            })
    }
    fn self_presence<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,
    {
        let XmppConnection {
            account,
            state: XmppState { client, data },
        } = self;
        use tokio::prelude::Sink;
        let presence = stanzas::make_presence(&account);
        let account2 = account.clone();
        info!("Sending presence... {:?}", presence);
        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,
                }
                .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());
                    self.state
                        .data
                        .pending_add_roster_ids
                        .insert(id_add_roster, xmpp_to.clone());
                    info!("Adding jid to roster... {:?}", add_roster);
                    self.state.data.send_queue.push_back(add_roster);
                }
            }
        }
    }
    pub fn process_command(&mut self, cmd: XmppCommand) {
        info!("Got command");
        match cmd {
            XmppCommand::Chat { xmpp_to, message } => {
                self.state
                    .data
                    .outgoing_mailbox
                    .entry(xmpp_to.clone())
                    .or_default()
                    .push(message);
                self.process_jid(&xmpp_to);
            }
            XmppCommand::Chatroom { muc_id, message } => {
                if let Some(muc) = self.state.data.mucs.get(&muc_id) {
                    self.state
                        .data
                        .send_queue
                        .push_back(stanzas::make_muc_message(muc.clone(), message));
                } else {
                    error!("Not found MUC {}", muc_id);
                }
            }
            XmppCommand::Ping => {
                self.state.data.counter += 1;
                let id_ping = format!("id_ping{}", self.state.data.counter);
                let ping = stanzas::make_ping(&id_ping, self.state.client.jid.clone());
                self.state.data.send_queue.push_back(ping);
            }
        }
    }
    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... {:?}", muc_presence);
            use tokio::prelude::Sink;
            client
                .send(Packet::Stanza(muc_presence))
                .map_err(|e| {
                    error!("Error on send muc presence: {}", e);
                    e
                })
                .and_then(|client| future::ok(XmppState { client, data }))
        })
        .map(|_| ())
    }
    fn enter_mucs<F, E>(
        self,
        _stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E> + 'static,
        E: Into<failure::Error> + 'static,
    {
        let XmppConnection { account, state } = self;
        let account2 = account.clone();
        let account3 = account.clone();
        stream::iter_ok(account.chatrooms.clone())
            .fold(state, move |XmppState { client, mut data }, muc_jid| {
                data.counter += 1;
                let id_muc_presence = format!("id_muc_presence{}", data.counter);
                let muc_presence = stanzas::make_muc_presence(
                    &id_muc_presence,
                    account2.jid.clone(),
                    muc_jid.1.clone(),
                );
                info!("Sending muc presence... {:?}", muc_presence);
                let account4 = account2.clone();
                use tokio::prelude::Sink;
                client
                    .send(Packet::Stanza(muc_presence))
                    .map_err(|e| {
                        error!("Error on send muc presence: {}", e);
                        account4
                    })
                    .and_then(|client| {
                        data.mucs.insert(muc_jid.0, muc_jid.1);
                        future::ok(XmppState { client, data })
                    })
            })
            .map(|state| XmppConnection {
                account: account3,
                state,
            })
    }
}

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

∅:D[4.11301] → [2.57738:58814]

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

[4.11301]

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

Deletion in src/main.rs at line 0 [5.17]

∅:D[5.17] → [6.3512:3533]

∅:D[6.3533] → [7.3862:3885]

∅:D[7.3885] → [8.26016:26045]

∅:D[9.13903] → [7.3885:3910]

∅:D[10.8831] → [7.3885:3910]

∅:D[8.26045] → [7.3885:3910]

∅:D[7.3885] → [7.3885:3910]

∅:D[7.3910] → [6.3581:3621]

∅:D[6.3581] → [6.3581:3621]

∅:D[4.12373] → [6.3643:3656]

∅:D[11.6980] → [6.3643:3656]

∅:D[12.3592] → [6.3643:3656]

∅:D[7.3933] → [6.3643:3656]

∅:D[6.3643] → [6.3643:3656]

∅:D[6.3656] → [7.3934:3990]

∅:D[7.3990] → [6.3712:3759]

∅:D[6.3712] → [6.3712:3759]

∅:D[6.3759] → [7.3991:4019]

∅:D[7.4019] → [6.3787:3839]

∅:D[6.3787] → [6.3787:3839]

∅:D[6.3839] → [7.4020:4055]

∅:D[7.4055] → [6.3874:3893]

∅:D[6.3874] → [6.3874:3893]

∅:D[6.3893] → [7.4056:4083]

∅:D[7.4083] → [6.3920:3921]

∅:D[6.3920] → [6.3920:3921]

∅:D[13.7528] → [6.3953:4000]

∅:D[14.35] → [6.3953:4000]

∅:D[15.57] → [6.3953:4000]

∅:D[4.12406] → [6.3953:4000]

∅:D[16.4527] → [6.3953:4000]

∅:D[11.7013] → [6.3953:4000]

∅:D[12.3625] → [6.3953:4000]

∅:D[17.10005] → [6.3953:4000]

∅:D[7.4116] → [6.3953:4000]

∅:D[6.3953] → [6.3953:4000]

∅:D[6.4000] → [7.4117:4153]

∅:D[7.4153] → [6.4036:4065]

∅:D[6.4036] → [6.4036:4065]

∅:D[6.4065] → [7.4154:4155]

∅:D[7.4155] → [2.58815:58867]

∅:D[18.9248] → [6.4092:4105]

∅:D[9.13948] → [6.4092:4105]

∅:D[19.44] → [6.4092:4105]

∅:D[13.7555] → [6.4092:4105]

∅:D[15.84] → [6.4092:4105]

∅:D[4.12433] → [6.4092:4105]

∅:D[2.58867] → [6.4092:4105]

∅:D[20.4140] → [6.4092:4105]

∅:D[10.8876] → [6.4092:4105]

∅:D[16.4554] → [6.4092:4105]

∅:D[21.26566] → [6.4092:4105]

∅:D[11.7040] → [6.4092:4105]

∅:D[22.89] → [6.4092:4105]

∅:D[12.3652] → [6.4092:4105]

∅:D[23.97] → [6.4092:4105]

∅:D[17.10032] → [6.4092:4105]

∅:D[24.122] → [6.4092:4105]

∅:D[7.4181] → [6.4092:4105]

∅:D[8.26090] → [6.4092:4105]

∅:D[6.4092] → [6.4092:4105]

∅:D[6.4105] → [7.4182:4209]

∅:D[14.56] → [21.30772:30773]

∅:D[7.4209] → [21.30772:30773]

∅:D[21.30772] → [21.30772:30773]

∅:D[21.30773] → [7.4210:4337]

∅:D[7.4337] → [8.26091:26092]

∅:D[8.26092] → [2.58868:58916]

∅:D[2.58916] → [8.26092:26249]

∅:D[8.26092] → [8.26092:26249]

∅:D[8.26249] → [2.58917:59230]

∅:D[2.59230] → [8.26410:27159]

∅:D[8.26410] → [8.26410:27159]

∅:D[8.27159] → [2.59231:59408]

∅:D[2.59408] → [8.27259:27443]

∅:D[8.27259] → [8.27259:27443]

∅:D[25.10822] → [26.8026:8027]

∅:D[27.7829] → [26.8026:8027]

∅:D[8.27443] → [26.8026:8027]

∅:D[26.8026] → [26.8026:8027]

∅:D[26.8027] → [8.27444:33338]

#![deny(deprecated)]
#![deny(missing_docs)]
#![deny(bare_trait_objects)]
//! XMPP client service
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;
use hyper::{Body, Request, Response, Server};
use tokio::runtime::current_thread;
use tokio::runtime::Runtime;
use tokio::prelude::{future, Future, Sink, Stream};
mod config;
use crate::config::Config;
mod xmpp;
use crate::xmpp::{xmpp_process, XmppCommand};
mod stoppable_receiver;
use crate::stoppable_receiver::stop_receiver;
/// Return future with body converted to String
fn body_to_string(req: Request<Body>) -> impl Future<Item = String, Error = failure::Error> {
    req.into_body()
        .map_err(std::convert::Into::into)
        .fold(Vec::new(), |mut acc, ch| {
            acc.extend_from_slice(&*ch);
            future::ok::<_, failure::Error>(acc)
        })
        .and_then(|acc| {
            std::str::from_utf8(&acc)
                .map(std::string::ToString::to_string)
                .map_err(std::convert::Into::into)
        })
}
struct ServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
impl hyper::service::Service for ServiceCmd {
    type ReqBody = Body;
    type ResBody = Body;
    type Error = failure::Error;
    type Future =
        Box<dyn Future<Item = Response<Self::ResBody>, Error = Self::Error> + Send + 'static>;
    fn call(&mut self, req: Request<Self::ReqBody>) -> Self::Future {
        let xmpp_to_opt = req.headers().get("X-XMPP-To");
        let xmpp_to_res: Result<xmpp_parsers::Jid, failure::Error> = xmpp_to_opt.map_or_else(
            || Err(format_err!("No X-XMPP-To header")),
            |xmpp_to| {
                std::str::from_utf8(xmpp_to.as_bytes())
                    .map_err(std::convert::Into::into)
                    .and_then(|s| {
                        std::str::FromStr::from_str(s)
                            .map_err(std::convert::Into::into)
                    })
            },
        );
        let xmpp_muc_opt = req
            .headers()
            .get("X-XMPP-Muc")
            .map(|h| h.to_str().map(std::string::ToString::to_string));
        match (xmpp_muc_opt, xmpp_to_res) {
            (None, Err(err)) => {
                warn!("Unknown destination: {}", err);
                Box::new(tokio::prelude::future::result(
                    Response::builder()
                        .status(hyper::StatusCode::BAD_REQUEST)
                        .body(Body::from(format!("Unknown destination: {}", err)))
                        .map_err(std::convert::Into::into),
                )) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
            (None, Ok(xmpp_to)) => {
                info!("Got request. Reading body...");
                let cmd_send = self.cmd_send.clone();
                Box::new(body_to_string(req).and_then(move |message: String| {
                    if !message.is_empty() {
                        Box::new(
                            cmd_send
                                .clone()
                                .send(XmppCommand::Chat { xmpp_to, message })
                                .then(|r| match r {
                                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from(
                                        "Accepted",
                                    ))),
                                    Err(e) => {
                                        error!("Command sent error: {}", e);
                                        tokio::prelude::future::result(
                                            Response::builder()
                                                .status(hyper::StatusCode::BAD_REQUEST)
                                                .body(Body::from(format!(
                                                    "Command sent error: {}",
                                                    e
                                                ))),
                                        )
                                    }
                                })
                                .map_err(std::convert::Into::into),
                        )
                    } else {
                        warn!("Empty message");
                        Box::new(tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from("Empty message"))
                                .map_err(std::convert::Into::into),
                        ))
                            as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                    }
                })) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
            (Some(Ok(muc_id)), _) => {
                info!("Got MUC request. Reading body...");
                let cmd_send = self.cmd_send.clone();
                Box::new(body_to_string(req).and_then(move |message: String| {
                    if !message.is_empty() {
                        Box::new(
                            cmd_send
                                .clone()
                                .send(XmppCommand::Chatroom { muc_id, message })
                                .then(|r| match r {
                                    Ok(_) => tokio::prelude::future::ok(Response::new(Body::from(
                                        "Accepted",
                                    ))),
                                    Err(e) => {
                                        error!("Command sent error: {}", e);
                                        tokio::prelude::future::result(
                                            Response::builder()
                                                .status(hyper::StatusCode::BAD_REQUEST)
                                                .body(Body::from(format!(
                                                    "Command sent error: {}",
                                                    e
                                                ))),
                                        )
                                    }
                                })
                                .map_err(std::convert::Into::into),
                        )
                    } else {
                        warn!("Empty message");
                        Box::new(tokio::prelude::future::result(
                            Response::builder()
                                .status(hyper::StatusCode::BAD_REQUEST)
                                .body(Body::from("Empty message"))
                                .map_err(std::convert::Into::into),
                        ))
                            as Box<dyn Future<Item = _, Error = _> + Send + 'static>
                    }
                })) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
            (Some(Err(err)), _) => {
                warn!("Unknown MUC destination: {}", err);
                Box::new(tokio::prelude::future::result(
                    Response::builder()
                        .status(hyper::StatusCode::BAD_REQUEST)
                        .body(Body::from(format!("Unknown MUC destination: {}", err)))
                        .map_err(std::convert::Into::into),
                )) as Box<dyn Future<Item = _, Error = _> + Send + 'static>
            }
        }
    }
}
struct MakeServiceCmd {
    cmd_send: tokio_channel::mpsc::Sender<XmppCommand>,
}
impl<Ctx> hyper::service::MakeService<Ctx> for MakeServiceCmd {
    type ReqBody = Body;
    type ResBody = Body;
    type Error = failure::Error;
    type Service = ServiceCmd;
    type Future = tokio::prelude::future::FutureResult<ServiceCmd, Self::MakeError>;
    type MakeError = hyper::http::Error;
    fn make_service(&mut self, _ctx: Ctx) -> Self::Future {
        tokio::prelude::future::ok(ServiceCmd {
            cmd_send: self.cmd_send.clone(),
        })
    }
}

Replacement in src/main.rs at line 1 [5.17]

∅:D[5.30] → [7.4338:4363]

∅:D[7.4363] → [6.4287:4638]

∅:D[6.4287] → [6.4287:4638]

∅:D[6.4638] → [7.4364:4398]

∅:D[14.177] → [6.4672:4673]

∅:D[7.4398] → [6.4672:4673]

∅:D[6.4672] → [6.4672:4673]

∅:D[6.4673] → [7.4399:4488]

∅:D[14.266] → [6.4762:4954]

∅:D[7.4488] → [6.4762:4954]

∅:D[6.4762] → [6.4762:4954]

∅:D[6.4954] → [7.4489:4596]

∅:D[13.7622] → [6.5020:5039]

∅:D[14.292] → [6.5020:5039]

∅:D[28.7021] → [6.5020:5039]

∅:D[29.7459] → [6.5020:5039]

∅:D[30.4716] → [6.5020:5039]

∅:D[31.13450] → [6.5020:5039]

∅:D[32.7309] → [6.5020:5039]

∅:D[17.10140] → [6.5020:5039]

∅:D[7.4596] → [6.5020:5039]

∅:D[6.5020] → [6.5020:5039]

∅:D[6.5105] → [6.5105:5106]

∅:D[6.5106] → [7.4597:4663]

∅:D[7.4663] → [6.5106:5155]

∅:D[6.5106] → [6.5106:5155]

∅:D[6.5155] → [2.59409:59453]

∅:D[18.14061] → [6.5935:5995]

∅:D[25.11304] → [6.5935:5995]

∅:D[9.18761] → [6.5935:5995]

∅:D[27.8200] → [6.5935:5995]

∅:D[13.8403] → [6.5935:5995]

∅:D[14.339] → [6.5935:5995]

∅:D[15.865] → [6.5935:5995]

∅:D[2.59453] → [6.5935:5995]

∅:D[33.2730] → [6.5935:5995]

∅:D[26.12916] → [6.5935:5995]

∅:D[20.9784] → [6.5935:5995]

∅:D[10.13689] → [6.5935:5995]

∅:D[16.5335] → [6.5935:5995]

∅:D[21.31379] → [6.5935:5995]

∅:D[11.7821] → [6.5935:5995]

∅:D[22.2941] → [6.5935:5995]

∅:D[34.5805] → [6.5935:5995]

∅:D[12.4433] → [6.5935:5995]

∅:D[23.4747] → [6.5935:5995]

∅:D[17.10921] → [6.5935:5995]

∅:D[24.5679] → [6.5935:5995]

∅:D[7.5444] → [6.5935:5995]

∅:D[6.5935] → [6.5935:5995]

∅:D[6.5995] → [7.5445:5561]

∅:D[14.396] → [6.6048:6049]

∅:D[7.5561] → [6.6048:6049]

∅:D[6.6048] → [6.6048:6049]

∅:D[25.12117] → [7.5562:6215]

∅:D[33.3543] → [7.5562:6215]

∅:D[26.13729] → [7.5562:6215]

∅:D[8.34224] → [7.5562:6215]

∅:D[6.6049] → [7.5562:6215]

    env_logger::init();
    let args = clap::App::new("SendXMPP")
        .version("0.1.0")
        .author("O01eg <o01eg@yandex.ru>")
        .arg(
            clap::Arg::with_name("config")
                .short("c")
                .long("config")
                .value_name("CONFIG")
                .help("File with configuration")
                .takes_value(true),
        )
        .get_matches();
    let config = Config::read(args.value_of("config").expect("Mandatory option config"))
        .expect("Cann't read config file");
    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();
    let (cmd_send, cmd_recv) = tokio_channel::mpsc::channel(10);
    let http_server = Server::bind(&config.http)
        .serve(MakeServiceCmd { cmd_send })
        .with_graceful_shutdown(ctrl_c.clone().map(|_| ()))
        .map_err(|e| error!("server error: {}", e));
    let mut rt = Runtime::new().expect("Cann't start tokio");
    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
    });
    info!("Server started");
    rt.shutdown_on_idle().wait().expect("Shutdown error");
    info!("Server stopped");
    xmpp_join
        .join()
        .expect("Join xmpp thread")
        .expect("Result xmpp thread");

[5.30]

[5.61]

    println!("Hello, world!");

Deletion in README.md at line 0 [5.76]

∅:D[5.76] → [8.35511:35736]

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

Deletion in Cargo.toml at line 6 [5.11995]
∅:D[5.12171] → [7.6336:6353]
```
edition = "2018"
```
Deletion in Cargo.toml at line 8 [5.11995]
∅:D[5.12187] → [6.6843:6857]
∅:D[6.6857] → [7.6354:6376]
∅:D[7.6376] → [6.6879:6900]
∅:D[6.6879] → [6.6879:6900]
∅:D[6.6900] → [8.35737:35776]
∅:D[18.14101] → [6.6935:6950]
∅:D[9.19159] → [6.6935:6950]
∅:D[14.1367] → [6.6935:6950]
∅:D[4.13261] → [6.6935:6950]
∅:D[10.14016] → [6.6935:6950]
∅:D[29.7626] → [6.6935:6950]
∅:D[21.31777] → [6.6935:6950]
∅:D[11.7857] → [6.6935:6950]
∅:D[12.4469] → [6.6935:6950]
∅:D[23.4764] → [6.6935:6950]
∅:D[7.6393] → [6.6935:6950]
∅:D[8.35776] → [6.6935:6950]
∅:D[6.6935] → [6.6935:6950]
∅:D[6.6950] → [2.59454:59467]
∅:D[25.13137] → [6.6963:7012]
∅:D[27.8586] → [6.6963:7012]
∅:D[4.13275] → [6.6963:7012]
∅:D[2.59467] → [6.6963:7012]
∅:D[35.3354] → [6.6963:7012]
∅:D[8.35790] → [6.6963:7012]
∅:D[6.6963] → [6.6963:7012]
∅:D[6.7012] → [7.6394:6425]
∅:D[7.6425] → [2.59468:59492]
∅:D[2.59492] → [8.35813:35848]
∅:D[8.35813] → [8.35813:35848]
∅:D[8.35848] → [2.59493:59528]
```
tokio = "0.1"
tokio-channel = "0.1"
tokio-signal = "0.2"
tokio-xmpp = "1.0.0"
failure = "0.1.5"
hyper = "0.12"
toml = "0.4"
serde = "1.0"
serde_derive = "1.0"
clap = "2.32"
log = "0.4"
env_logger = "0.6"
xmpp-parsers = "0.12.2"
minidom = "=0.10.0" # xmpp-parsers
try_from = "=0.3.2" # xmpp-parsers
```
Deletion in Cargo.lock at line 0 [5.12201]
∅:D[5.12201] → [8.35849:35940]
∅:D[25.13252] → [7.6543:6555]
∅:D[26.14976] → [7.6543:6555]
∅:D[10.14321] → [7.6543:6555]
∅:D[36.1041] → [7.6543:6555]
∅:D[8.35940] → [7.6543:6555]
∅:D[5.12201] → [7.6543:6555]
∅:D[7.6555] → [8.35941:36063]
∅:D[8.36063] → [2.59529:59601]
∅:D[2.59601] → [8.36135:36150]
∅:D[8.36135] → [8.36135:36150]
∅:D[9.19464] → [7.6555:6577]
∅:D[8.36150] → [7.6555:6577]
∅:D[7.6555] → [7.6555:6577]
∅:D[7.6577] → [2.59602:59621]
∅:D[37.19] → [7.6595:6677]
∅:D[25.13344] → [7.6595:6677]
∅:D[27.8703] → [7.6595:6677]
∅:D[4.13413] → [7.6595:6677]
∅:D[2.59621] → [7.6595:6677]
∅:D[26.15069] → [7.6595:6677]
∅:D[34.5897] → [7.6595:6677]
∅:D[38.4111] → [7.6595:6677]
∅:D[36.1134] → [7.6595:6677]
∅:D[8.36169] → [7.6595:6677]
∅:D[7.6595] → [7.6595:6677]
∅:D[7.6677] → [8.36170:36243]
∅:D[37.93] → [7.6750:6753]
∅:D[25.13418] → [7.6750:6753]
∅:D[9.19538] → [7.6750:6753]
∅:D[27.8777] → [7.6750:6753]
∅:D[4.13487] → [7.6750:6753]
∅:D[26.15143] → [7.6750:6753]
∅:D[10.14395] → [7.6750:6753]
∅:D[34.5971] → [7.6750:6753]
∅:D[12.4662] → [7.6750:6753]
∅:D[38.4185] → [7.6750:6753]
∅:D[36.1208] → [7.6750:6753]
∅:D[8.36243] → [7.6750:6753]
∅:D[7.6750] → [7.6750:6753]
∅:D[7.6753] → [6.7323:7455]
∅:D[6.7323] → [6.7323:7455]
∅:D[6.7455] → [2.59622:59695]
∅:D[25.13492] → [6.7528:7561]
∅:D[4.13561] → [6.7528:7561]
∅:D[2.59695] → [6.7528:7561]
∅:D[8.36317] → [6.7528:7561]
∅:D[6.7528] → [6.7528:7561]
∅:D[6.7561] → [2.59696:59714]
∅:D[2.59714] → [4.13580:13658]
∅:D[8.36337] → [4.13580:13658]
∅:D[4.13580] → [4.13580:13658]
∅:D[6.7771] → [6.7771:7789]
∅:D[6.7789] → [8.36338:36357]
∅:D[18.14519] → [6.7807:7889]
∅:D[9.19577] → [6.7807:7889]
∅:D[14.1521] → [6.7807:7889]
∅:D[15.1188] → [6.7807:7889]
∅:D[4.13713] → [6.7807:7889]
∅:D[20.10201] → [6.7807:7889]
∅:D[10.14434] → [6.7807:7889]
∅:D[29.7949] → [6.7807:7889]
∅:D[21.32195] → [6.7807:7889]
∅:D[11.8153] → [6.7807:7889]
∅:D[39.5319] → [6.7807:7889]
∅:D[22.3034] → [6.7807:7889]
∅:D[31.13701] → [6.7807:7889]
∅:D[12.4814] → [6.7807:7889]
∅:D[23.4876] → [6.7807:7889]
∅:D[24.5791] → [6.7807:7889]
∅:D[7.6791] → [6.7807:7889]
∅:D[8.36357] → [6.7807:7889]
∅:D[6.7807] → [6.7807:7889]
∅:D[6.7889] → [7.6792:6866]
∅:D[14.1596] → [6.7963:8093]
∅:D[7.6866] → [6.7963:8093]
∅:D[6.7963] → [6.7963:8093]
∅:D[6.8093] → [2.59715:59787]
∅:D[18.14592] → [6.8165:8239]
∅:D[25.13585] → [6.8165:8239]
∅:D[9.19650] → [6.8165:8239]
∅:D[27.8850] → [6.8165:8239]
∅:D[14.1669] → [6.8165:8239]
∅:D[15.1261] → [6.8165:8239]
∅:D[4.13786] → [6.8165:8239]
∅:D[2.59787] → [6.8165:8239]
∅:D[33.4618] → [6.8165:8239]
∅:D[35.3523] → [6.8165:8239]
∅:D[26.15216] → [6.8165:8239]
∅:D[20.10274] → [6.8165:8239]
∅:D[10.14507] → [6.8165:8239]
∅:D[29.8022] → [6.8165:8239]
∅:D[21.32268] → [6.8165:8239]
∅:D[11.8226] → [6.8165:8239]
∅:D[39.5392] → [6.8165:8239]
∅:D[22.3107] → [6.8165:8239]
∅:D[31.13774] → [6.8165:8239]
∅:D[34.6044] → [6.8165:8239]
∅:D[12.4887] → [6.8165:8239]
∅:D[23.4949] → [6.8165:8239]
∅:D[36.1281] → [6.8165:8239]
∅:D[24.5864] → [6.8165:8239]
∅:D[7.6939] → [6.8165:8239]
∅:D[8.36430] → [6.8165:8239]
∅:D[6.8165] → [6.8165:8239]
∅:D[6.8239] → [2.59788:59861]
∅:D[25.13659] → [6.8312:8314]
∅:D[4.13860] → [6.8312:8314]
∅:D[2.59861] → [6.8312:8314]
∅:D[8.36504] → [6.8312:8314]
∅:D[6.8312] → [6.8312:8314]
∅:D[20.10375] → [20.10375:10388]
∅:D[20.10388] → [8.36505:36540]
∅:D[18.14628] → [6.8364:8429]
∅:D[9.19686] → [6.8364:8429]
∅:D[14.1707] → [6.8364:8429]
∅:D[4.13898] → [6.8364:8429]
∅:D[10.14543] → [6.8364:8429]
∅:D[21.32304] → [6.8364:8429]
∅:D[11.8264] → [6.8364:8429]
∅:D[12.4925] → [6.8364:8429]
∅:D[8.36540] → [6.8364:8429]
∅:D[6.8364] → [6.8364:8429]
∅:D[14.2264] → [6.8985:9017]
∅:D[4.14455] → [6.8985:9017]
∅:D[11.8821] → [6.8985:9017]
∅:D[12.5482] → [6.8985:9017]
∅:D[6.8985] → [6.8985:9017]
∅:D[6.9017] → [2.59862:59881]
∅:D[18.14648] → [6.9035:9117]
∅:D[25.13679] → [6.9035:9117]
∅:D[9.19706] → [6.9035:9117]
∅:D[27.8870] → [6.9035:9117]
∅:D[14.2283] → [6.9035:9117]
∅:D[15.1632] → [6.9035:9117]
∅:D[4.14474] → [6.9035:9117]
∅:D[2.59881] → [6.9035:9117]
∅:D[26.15236] → [6.9035:9117]
∅:D[20.10645] → [6.9035:9117]
∅:D[10.14563] → [6.9035:9117]
∅:D[29.8393] → [6.9035:9117]
∅:D[21.32324] → [6.9035:9117]
∅:D[11.8840] → [6.9035:9117]
∅:D[39.5763] → [6.9035:9117]
∅:D[22.3362] → [6.9035:9117]
∅:D[31.14029] → [6.9035:9117]
∅:D[34.6064] → [6.9035:9117]
∅:D[12.5501] → [6.9035:9117]
∅:D[23.5204] → [6.9035:9117]
∅:D[36.1301] → [6.9035:9117]
∅:D[24.6119] → [6.9035:9117]
∅:D[8.36560] → [6.9035:9117]
∅:D[6.9035] → [6.9035:9117]
∅:D[6.9117] → [8.36561:36716]
∅:D[8.36716] → [2.59882:60182]
∅:D[25.13980] → [6.9497:9535]
∅:D[4.14855] → [6.9497:9535]
∅:D[2.60182] → [6.9497:9535]
∅:D[8.37016] → [6.9497:9535]
∅:D[6.9497] → [6.9497:9535]
∅:D[6.9535] → [8.37017:37036]
∅:D[18.14979] → [6.9554:9636]
∅:D[9.20037] → [6.9554:9636]
∅:D[14.2539] → [6.9554:9636]
∅:D[15.1963] → [6.9554:9636]
∅:D[4.14875] → [6.9554:9636]
∅:D[20.10976] → [6.9554:9636]
∅:D[10.14894] → [6.9554:9636]
∅:D[29.8724] → [6.9554:9636]
∅:D[21.32655] → [6.9554:9636]
∅:D[11.9096] → [6.9554:9636]
∅:D[39.6094] → [6.9554:9636]
∅:D[22.3618] → [6.9554:9636]
∅:D[31.14285] → [6.9554:9636]
∅:D[12.5757] → [6.9554:9636]
∅:D[23.5460] → [6.9554:9636]
∅:D[24.6375] → [6.9554:9636]
∅:D[8.37036] → [6.9554:9636]
∅:D[6.9554] → [6.9554:9636]
∅:D[6.9636] → [2.60183:60325]
∅:D[18.15122] → [6.9778:9809]
∅:D[25.14123] → [6.9778:9809]
∅:D[9.20180] → [6.9778:9809]
∅:D[27.9159] → [6.9778:9809]
∅:D[14.2682] → [6.9778:9809]
∅:D[15.2106] → [6.9778:9809]
∅:D[4.15018] → [6.9778:9809]
∅:D[2.60325] → [6.9778:9809]
∅:D[33.4837] → [6.9778:9809]
∅:D[35.3812] → [6.9778:9809]
∅:D[26.15452] → [6.9778:9809]
∅:D[20.11119] → [6.9778:9809]
∅:D[10.15037] → [6.9778:9809]
∅:D[29.8867] → [6.9778:9809]
∅:D[21.32798] → [6.9778:9809]
∅:D[11.9239] → [6.9778:9809]
∅:D[39.6237] → [6.9778:9809]
∅:D[22.3761] → [6.9778:9809]
∅:D[31.14428] → [6.9778:9809]
∅:D[34.6280] → [6.9778:9809]
∅:D[12.5900] → [6.9778:9809]
∅:D[23.5603] → [6.9778:9809]
∅:D[36.1590] → [6.9778:9809]
∅:D[24.6518] → [6.9778:9809]
∅:D[7.7158] → [6.9778:9809]
∅:D[8.37179] → [6.9778:9809]
∅:D[6.9778] → [6.9778:9809]
∅:D[6.9809] → [8.37180:37199]
∅:D[18.15142] → [6.9827:9909]
∅:D[9.20200] → [6.9827:9909]
∅:D[14.2701] → [6.9827:9909]
∅:D[4.15037] → [6.9827:9909]
∅:D[10.15057] → [6.9827:9909]
∅:D[21.32818] → [6.9827:9909]
∅:D[11.9258] → [6.9827:9909]
∅:D[12.5919] → [6.9827:9909]
∅:D[8.37199] → [6.9827:9909]
∅:D[6.9827] → [6.9827:9909]
∅:D[6.9909] → [8.37200:37276]
∅:D[18.15219] → [6.10059:10204]
∅:D[9.20277] → [6.10059:10204]
∅:D[14.2852] → [6.10059:10204]
∅:D[4.15188] → [6.10059:10204]
∅:D[10.15134] → [6.10059:10204]
∅:D[21.32895] → [6.10059:10204]
∅:D[11.9409] → [6.10059:10204]
∅:D[12.6070] → [6.10059:10204]
∅:D[8.37276] → [6.10059:10204]
∅:D[6.10059] → [6.10059:10204]
∅:D[6.10204] → [8.37277:37295]
∅:D[18.15238] → [6.10222:10304]
∅:D[9.20296] → [6.10222:10304]
∅:D[14.2871] → [6.10222:10304]
∅:D[4.15207] → [6.10222:10304]
∅:D[10.15153] → [6.10222:10304]
∅:D[21.32914] → [6.10222:10304]
∅:D[11.9428] → [6.10222:10304]
∅:D[12.6089] → [6.10222:10304]
∅:D[8.37295] → [6.10222:10304]
∅:D[6.10222] → [6.10222:10304]
∅:D[6.10304] → [8.37296:37602]
∅:D[18.15545] → [6.10531:10568]
∅:D[9.20603] → [6.10531:10568]
∅:D[14.3099] → [6.10531:10568]
∅:D[4.15435] → [6.10531:10568]
∅:D[10.15460] → [6.10531:10568]
∅:D[21.33221] → [6.10531:10568]
∅:D[11.9656] → [6.10531:10568]
∅:D[12.6317] → [6.10531:10568]
∅:D[8.37602] → [6.10531:10568]
∅:D[6.10531] → [6.10531:10568]
∅:D[6.10568] → [8.37603:38073]
∅:D[37.112] → [10.15479:15561]
∅:D[25.14142] → [10.15479:15561]
∅:D[9.20622] → [10.15479:15561]
∅:D[27.9178] → [10.15479:15561]
∅:D[4.15454] → [10.15479:15561]
∅:D[26.15471] → [10.15479:15561]
∅:D[34.6299] → [10.15479:15561]
∅:D[12.6336] → [10.15479:15561]
∅:D[38.4204] → [10.15479:15561]
∅:D[36.1609] → [10.15479:15561]
∅:D[8.38073] → [10.15479:15561]
∅:D[10.15479] → [10.15479:15561]
∅:D[10.15561] → [8.38074:38151]
∅:D[4.15607] → [9.20937:20952]
∅:D[8.38151] → [9.20937:20952]
∅:D[9.20937] → [9.20937:20952]
∅:D[6.10835] → [6.10835:10855]
∅:D[6.10855] → [8.38152:38170]
∅:D[18.16113] → [6.10873:10970]
∅:D[9.21171] → [6.10873:10970]
∅:D[14.3290] → [6.10873:10970]
∅:D[4.15626] → [6.10873:10970]
∅:D[10.16028] → [6.10873:10970]
∅:D[21.33789] → [6.10873:10970]
∅:D[11.9847] → [6.10873:10970]
∅:D[12.6508] → [6.10873:10970]
∅:D[8.38170] → [6.10873:10970]
∅:D[6.10873] → [6.10873:10970]
∅:D[6.10970] → [8.38171:38189]
∅:D[18.16132] → [6.10988:11081]
∅:D[9.21190] → [6.10988:11081]
∅:D[14.3309] → [6.10988:11081]
∅:D[4.15645] → [6.10988:11081]
∅:D[10.16047] → [6.10988:11081]
∅:D[21.33808] → [6.10988:11081]
∅:D[11.9866] → [6.10988:11081]
∅:D[12.6527] → [6.10988:11081]
∅:D[8.38189] → [6.10988:11081]
∅:D[6.10988] → [6.10988:11081]
∅:D[6.11081] → [2.60326:60345]
∅:D[25.14162] → [6.11100:11182]
∅:D[27.9198] → [6.11100:11182]
∅:D[14.3329] → [6.11100:11182]
∅:D[4.15665] → [6.11100:11182]
∅:D[2.60345] → [6.11100:11182]
∅:D[33.4857] → [6.11100:11182]
∅:D[35.3832] → [6.11100:11182]
∅:D[36.1629] → [6.11100:11182]
∅:D[7.7178] → [6.11100:11182]
∅:D[8.38209] → [6.11100:11182]
∅:D[6.11100] → [6.11100:11182]
∅:D[6.11182] → [8.38210:38286]
∅:D[18.16209] → [6.11258:11467]
∅:D[9.21267] → [6.11258:11467]
∅:D[14.3406] → [6.11258:11467]
∅:D[4.15742] → [6.11258:11467]
∅:D[10.16124] → [6.11258:11467]
∅:D[21.33885] → [6.11258:11467]
∅:D[11.9943] → [6.11258:11467]
∅:D[12.6604] → [6.11258:11467]
∅:D[8.38286] → [6.11258:11467]
∅:D[6.11258] → [6.11258:11467]
∅:D[6.11467] → [2.60346:60365]
∅:D[18.16229] → [6.11486:11580]
∅:D[25.14182] → [6.11486:11580]
∅:D[9.21287] → [6.11486:11580]
∅:D[27.9218] → [6.11486:11580]
∅:D[14.3426] → [6.11486:11580]
∅:D[15.2126] → [6.11486:11580]
∅:D[4.15762] → [6.11486:11580]
∅:D[2.60365] → [6.11486:11580]
∅:D[35.3852] → [6.11486:11580]
∅:D[26.15491] → [6.11486:11580]
∅:D[20.11139] → [6.11486:11580]
∅:D[10.16144] → [6.11486:11580]
∅:D[29.8887] → [6.11486:11580]
∅:D[21.33905] → [6.11486:11580]
∅:D[11.9963] → [6.11486:11580]
∅:D[39.6257] → [6.11486:11580]
∅:D[22.3781] → [6.11486:11580]
∅:D[31.14448] → [6.11486:11580]
∅:D[34.6319] → [6.11486:11580]
∅:D[12.6624] → [6.11486:11580]
∅:D[23.5623] → [6.11486:11580]
∅:D[36.1649] → [6.11486:11580]
∅:D[24.6538] → [6.11486:11580]
∅:D[8.38306] → [6.11486:11580]
∅:D[6.11486] → [6.11486:11580]
∅:D[6.11580] → [2.60366:60384]
∅:D[25.14201] → [6.11598:11948]
∅:D[27.9237] → [6.11598:11948]
∅:D[4.15781] → [6.11598:11948]
∅:D[2.60384] → [6.11598:11948]
∅:D[33.4876] → [6.11598:11948]
∅:D[35.3871] → [6.11598:11948]
∅:D[36.1668] → [6.11598:11948]
∅:D[8.38325] → [6.11598:11948]
∅:D[6.11598] → [6.11598:11948]
∅:D[6.11948] → [8.38326:38398]
∅:D[18.16302] → [6.12020:12049]
∅:D[9.21360] → [6.12020:12049]
∅:D[14.3499] → [6.12020:12049]
∅:D[15.2199] → [6.12020:12049]
∅:D[4.15854] → [6.12020:12049]
∅:D[20.11212] → [6.12020:12049]
∅:D[10.16217] → [6.12020:12049]
∅:D[29.8960] → [6.12020:12049]
∅:D[21.33978] → [6.12020:12049]
∅:D[11.10036] → [6.12020:12049]
∅:D[39.6330] → [6.12020:12049]
∅:D[22.3854] → [6.12020:12049]
∅:D[31.14521] → [6.12020:12049]
∅:D[12.6697] → [6.12020:12049]
∅:D[23.5696] → [6.12020:12049]
∅:D[24.6611] → [6.12020:12049]
∅:D[8.38398] → [6.12020:12049]
∅:D[6.12020] → [6.12020:12049]
∅:D[6.12049] → [2.60385:60404]
∅:D[25.14221] → [6.12068:12374]
∅:D[4.15874] → [6.12068:12374]
∅:D[2.60404] → [6.12068:12374]
∅:D[8.38418] → [6.12068:12374]
∅:D[6.12068] → [6.12068:12374]
∅:D[6.12374] → [2.60405:60554]
∅:D[25.14371] → [6.12523:12887]
∅:D[4.16024] → [6.12523:12887]
∅:D[2.60554] → [6.12523:12887]
∅:D[8.38568] → [6.12523:12887]
∅:D[6.12523] → [6.12523:12887]
∅:D[14.3622] → [6.13009:13233]
∅:D[4.16147] → [6.13009:13233]
∅:D[11.10159] → [6.13009:13233]
∅:D[12.6820] → [6.13009:13233]
∅:D[6.13009] → [6.13009:13233]
∅:D[6.13233] → [2.60555:60627]
∅:D[18.16375] → [6.13305:13367]
∅:D[25.14444] → [6.13305:13367]
∅:D[9.21433] → [6.13305:13367]
∅:D[27.9310] → [6.13305:13367]
∅:D[14.3695] → [6.13305:13367]
∅:D[15.2272] → [6.13305:13367]
∅:D[4.16220] → [6.13305:13367]
∅:D[2.60627] → [6.13305:13367]
∅:D[33.4949] → [6.13305:13367]
∅:D[35.3944] → [6.13305:13367]
∅:D[26.15564] → [6.13305:13367]
∅:D[20.11285] → [6.13305:13367]
∅:D[10.16290] → [6.13305:13367]
∅:D[29.9033] → [6.13305:13367]
∅:D[21.34051] → [6.13305:13367]
∅:D[11.10232] → [6.13305:13367]
∅:D[39.6403] → [6.13305:13367]
∅:D[22.3927] → [6.13305:13367]
∅:D[31.14594] → [6.13305:13367]
∅:D[34.6392] → [6.13305:13367]
∅:D[12.6893] → [6.13305:13367]
∅:D[23.5769] → [6.13305:13367]
∅:D[36.1741] → [6.13305:13367]
∅:D[24.6684] → [6.13305:13367]
∅:D[7.7251] → [6.13305:13367]
∅:D[8.38641] → [6.13305:13367]
∅:D[6.13305] → [6.13305:13367]
∅:D[27.10035] → [27.10035:10117]
∅:D[27.10117] → [2.60628:60700]
∅:D[18.17080] → [6.13825:13840]
∅:D[25.14517] → [6.13825:13840]
∅:D[9.22757] → [6.13825:13840]
∅:D[27.10193] → [6.13825:13840]
∅:D[14.3952] → [6.13825:13840]
∅:D[15.2529] → [6.13825:13840]
∅:D[4.16293] → [6.13825:13840]
∅:D[2.60700] → [6.13825:13840]
∅:D[20.11542] → [6.13825:13840]
∅:D[10.16995] → [6.13825:13840]
∅:D[29.9290] → [6.13825:13840]
∅:D[21.34756] → [6.13825:13840]
∅:D[11.10489] → [6.13825:13840]
∅:D[39.6660] → [6.13825:13840]
∅:D[22.4184] → [6.13825:13840]
∅:D[31.14851] → [6.13825:13840]
∅:D[12.7150] → [6.13825:13840]
∅:D[23.6026] → [6.13825:13840]
∅:D[24.6941] → [6.13825:13840]
∅:D[7.7508] → [6.13825:13840]
∅:D[8.38714] → [6.13825:13840]
∅:D[6.13825] → [6.13825:13840]
∅:D[6.13840] → [27.10194:10219]
∅:D[27.10219] → [8.38715:38733]
∅:D[18.17099] → [6.13883:13965]
∅:D[25.14536] → [6.13883:13965]
∅:D[9.22776] → [6.13883:13965]
∅:D[27.10237] → [6.13883:13965]
∅:D[14.3971] → [6.13883:13965]
∅:D[15.2548] → [6.13883:13965]
∅:D[4.16312] → [6.13883:13965]
∅:D[20.11561] → [6.13883:13965]
∅:D[10.17014] → [6.13883:13965]
∅:D[29.9309] → [6.13883:13965]
∅:D[21.34775] → [6.13883:13965]
∅:D[11.10508] → [6.13883:13965]
∅:D[39.6679] → [6.13883:13965]
∅:D[22.4203] → [6.13883:13965]
∅:D[31.14870] → [6.13883:13965]
∅:D[12.7169] → [6.13883:13965]
∅:D[23.6045] → [6.13883:13965]
∅:D[24.6960] → [6.13883:13965]
∅:D[7.7527] → [6.13883:13965]
∅:D[8.38733] → [6.13883:13965]
∅:D[6.13883] → [6.13883:13965]
∅:D[6.13965] → [8.38734:38898]
∅:D[4.16477] → [26.15736:15751]
∅:D[8.38898] → [26.15736:15751]
∅:D[6.14426] → [26.15736:15751]
∅:D[26.15751] → [27.10321:10346]
∅:D[27.10346] → [8.38899:38917]
∅:D[27.10364] → [26.15794:15876]
∅:D[4.16496] → [26.15794:15876]
∅:D[8.38917] → [26.15794:15876]
∅:D[26.15794] → [26.15794:15876]
∅:D[26.15876] → [8.38918:38994]
∅:D[8.38994] → [2.60701:60774]
∅:D[2.60774] → [8.39067:39227]
∅:D[8.39067] → [8.39067:39227]
∅:D[25.14689] → [27.10593:10746]
∅:D[4.16805] → [27.10593:10746]
∅:D[8.39227] → [27.10593:10746]
∅:D[27.10593] → [27.10593:10746]
∅:D[27.10746] → [6.14426:14441]
∅:D[26.15958] → [6.14426:14441]
∅:D[36.2209] → [6.14426:14441]
∅:D[6.14426] → [6.14426:14441]
∅:D[6.14441] → [8.39228:39271]
∅:D[4.16849] → [25.14733:14815]
∅:D[8.39271] → [25.14733:14815]
∅:D[25.14733] → [25.14733:14815]
∅:D[25.14815] → [8.39272:39354]
∅:D[4.16923] → [25.14897:14912]
∅:D[8.39354] → [25.14897:14912]
∅:D[25.14897] → [25.14897:14912]
∅:D[25.14912] → [8.39355:39398]
∅:D[9.22955] → [14.4227:4292]
∅:D[4.16962] → [14.4227:4292]
∅:D[10.17193] → [14.4227:4292]
∅:D[12.7347] → [14.4227:4292]
∅:D[7.7783] → [14.4227:4292]
∅:D[8.39398] → [14.4227:4292]
∅:D[14.4227] → [14.4227:4292]
∅:D[14.4292] → [7.7784:7801]
∅:D[7.7801] → [2.60775:60848]
∅:D[2.60848] → [8.39472:39550]
∅:D[8.39472] → [8.39472:39550]
∅:D[25.15064] → [7.7874:7876]
∅:D[9.23034] → [7.7874:7876]
∅:D[27.10898] → [7.7874:7876]
∅:D[4.17126] → [7.7874:7876]
∅:D[26.16037] → [7.7874:7876]
∅:D[34.7709] → [7.7874:7876]
∅:D[36.2361] → [7.7874:7876]
∅:D[8.39550] → [7.7874:7876]
∅:D[7.7874] → [7.7874:7876]
∅:D[7.7876] → [14.4292:4305]
∅:D[14.4292] → [14.4292:4305]
∅:D[14.4305] → [8.39551:39589]
∅:D[9.23053] → [12.7366:7448]
∅:D[4.17166] → [12.7366:7448]
∅:D[8.39589] → [12.7366:7448]
∅:D[12.7366] → [12.7366:7448]
∅:D[12.7448] → [8.39590:39744]
∅:D[9.23208] → [12.7611:7626]
∅:D[4.17319] → [12.7611:7626]
∅:D[8.39744] → [12.7611:7626]
∅:D[12.7611] → [12.7611:7626]
∅:D[6.15240] → [6.15240:15609]
∅:D[6.15609] → [8.39745:39763]
∅:D[18.17471] → [6.15627:15709]
∅:D[9.23227] → [6.15627:15709]
∅:D[14.4719] → [6.15627:15709]
∅:D[4.17338] → [6.15627:15709]
∅:D[10.17386] → [6.15627:15709]
∅:D[21.35147] → [6.15627:15709]
∅:D[11.11176] → [6.15627:15709]
∅:D[12.7837] → [6.15627:15709]
∅:D[8.39763] → [6.15627:15709]
∅:D[6.15627] → [6.15627:15709]
∅:D[6.15709] → [8.39764:39845]
∅:D[18.17553] → [6.15789:15825]
∅:D[9.23309] → [6.15789:15825]
∅:D[14.4800] → [6.15789:15825]
∅:D[4.17419] → [6.15789:15825]
∅:D[10.17468] → [6.15789:15825]
∅:D[21.35229] → [6.15789:15825]
∅:D[11.11257] → [6.15789:15825]
∅:D[12.7918] → [6.15789:15825]
∅:D[8.39845] → [6.15789:15825]
∅:D[6.15789] → [6.15789:15825]
∅:D[6.15825] → [8.39846:39865]
∅:D[37.285] → [6.15844:15926]
∅:D[18.17573] → [6.15844:15926]
∅:D[25.15084] → [6.15844:15926]
∅:D[9.23329] → [6.15844:15926]
∅:D[27.10918] → [6.15844:15926]
∅:D[14.4820] → [6.15844:15926]
∅:D[15.2747] → [6.15844:15926]
∅:D[4.17439] → [6.15844:15926]
∅:D[26.16057] → [6.15844:15926]
∅:D[20.11760] → [6.15844:15926]
∅:D[10.17488] → [6.15844:15926]
∅:D[29.9508] → [6.15844:15926]
∅:D[21.35249] → [6.15844:15926]
∅:D[11.11277] → [6.15844:15926]
∅:D[39.6877] → [6.15844:15926]
∅:D[22.4401] → [6.15844:15926]
∅:D[31.15068] → [6.15844:15926]
∅:D[34.7729] → [6.15844:15926]
∅:D[12.7938] → [6.15844:15926]
∅:D[23.6243] → [6.15844:15926]
∅:D[38.4376] → [6.15844:15926]
∅:D[36.2381] → [6.15844:15926]
∅:D[24.7158] → [6.15844:15926]
∅:D[7.7896] → [6.15844:15926]
∅:D[8.39865] → [6.15844:15926]
∅:D[6.15844] → [6.15844:15926]
∅:D[6.15926] → [2.60849:60922]
∅:D[25.15158] → [7.7897:7932]
∅:D[27.10992] → [7.7897:7932]
∅:D[4.17513] → [7.7897:7932]
∅:D[2.60922] → [7.7897:7932]
∅:D[33.5244] → [7.7897:7932]
∅:D[35.4239] → [7.7897:7932]
∅:D[36.2455] → [7.7897:7932]
∅:D[8.39939] → [7.7897:7932]
∅:D[6.15999] → [7.7897:7932]
∅:D[7.7932] → [2.60923:60941]
∅:D[25.15177] → [7.7950:8250]
∅:D[27.11011] → [7.7950:8250]
∅:D[4.17532] → [7.7950:8250]
∅:D[2.60941] → [7.7950:8250]
∅:D[33.5263] → [7.7950:8250]
∅:D[35.4258] → [7.7950:8250]
∅:D[36.2474] → [7.7950:8250]
∅:D[8.39958] → [7.7950:8250]
∅:D[7.7950] → [7.7950:8250]
∅:D[7.8250] → [2.60942:61014]
∅:D[25.15250] → [7.8322:8398]
∅:D[9.23402] → [7.8322:8398]
∅:D[27.11084] → [7.8322:8398]
∅:D[4.17605] → [7.8322:8398]
∅:D[2.61014] → [7.8322:8398]
∅:D[26.16130] → [7.8322:8398]
∅:D[10.17561] → [7.8322:8398]
∅:D[34.7802] → [7.8322:8398]
∅:D[12.8011] → [7.8322:8398]
∅:D[36.2547] → [7.8322:8398]
∅:D[8.40031] → [7.8322:8398]
∅:D[7.8322] → [7.8322:8398]
∅:D[7.8398] → [6.15999:16014]
∅:D[6.15999] → [6.15999:16014]
∅:D[6.16014] → [14.4821:4842]
∅:D[4.17819] → [6.16749:16849]
∅:D[11.11564] → [6.16749:16849]
∅:D[12.8225] → [6.16749:16849]
∅:D[6.16749] → [6.16749:16849]
∅:D[6.16849] → [2.61015:61092]
∅:D[18.17724] → [6.16925:16957]
∅:D[25.15328] → [6.16925:16957]
∅:D[9.23480] → [6.16925:16957]
∅:D[27.11162] → [6.16925:16957]
∅:D[14.5015] → [6.16925:16957]
∅:D[15.2898] → [6.16925:16957]
∅:D[4.17896] → [6.16925:16957]
∅:D[2.61092] → [6.16925:16957]
∅:D[26.16208] → [6.16925:16957]
∅:D[20.11911] → [6.16925:16957]
∅:D[10.17639] → [6.16925:16957]
∅:D[29.9659] → [6.16925:16957]
∅:D[21.35400] → [6.16925:16957]
∅:D[11.11641] → [6.16925:16957]
∅:D[39.7028] → [6.16925:16957]
∅:D[22.4551] → [6.16925:16957]
∅:D[31.15218] → [6.16925:16957]
∅:D[34.7880] → [6.16925:16957]
∅:D[12.8302] → [6.16925:16957]
∅:D[23.6393] → [6.16925:16957]
∅:D[36.2625] → [6.16925:16957]
∅:D[24.7308] → [6.16925:16957]
∅:D[8.40109] → [6.16925:16957]
∅:D[6.16925] → [6.16925:16957]
∅:D[6.16957] → [8.40110:40128]
∅:D[18.17743] → [6.16975:17057]
∅:D[9.23499] → [6.16975:17057]
∅:D[14.5034] → [6.16975:17057]
∅:D[4.17915] → [6.16975:17057]
∅:D[10.17658] → [6.16975:17057]
∅:D[29.9678] → [6.16975:17057]
∅:D[21.35419] → [6.16975:17057]
∅:D[11.11660] → [6.16975:17057]
∅:D[12.8321] → [6.16975:17057]
∅:D[23.6412] → [6.16975:17057]
∅:D[8.40128] → [6.16975:17057]
∅:D[6.16975] → [6.16975:17057]
∅:D[6.17057] → [2.61093:61170]
∅:D[2.61170] → [8.40206:40287]
∅:D[8.40206] → [8.40206:40287]
∅:D[18.17902] → [6.17214:17253]
∅:D[9.23658] → [6.17214:17253]
∅:D[14.5192] → [6.17214:17253]
∅:D[4.18073] → [6.17214:17253]
∅:D[10.17817] → [6.17214:17253]
∅:D[29.9837] → [6.17214:17253]
∅:D[21.35578] → [6.17214:17253]
∅:D[11.11818] → [6.17214:17253]
∅:D[12.8479] → [6.17214:17253]
∅:D[23.6570] → [6.17214:17253]
∅:D[8.40287] → [6.17214:17253]
∅:D[6.17214] → [6.17214:17253]
∅:D[6.17253] → [8.40288:40306]
∅:D[18.17921] → [6.17271:17353]
∅:D[9.23677] → [6.17271:17353]
∅:D[14.5211] → [6.17271:17353]
∅:D[4.18092] → [6.17271:17353]
∅:D[10.17836] → [6.17271:17353]
∅:D[29.9856] → [6.17271:17353]
∅:D[21.35597] → [6.17271:17353]
∅:D[11.11837] → [6.17271:17353]
∅:D[12.8498] → [6.17271:17353]
∅:D[23.6589] → [6.17271:17353]
∅:D[8.40306] → [6.17271:17353]
∅:D[6.17271] → [6.17271:17353]
∅:D[6.17353] → [8.40307:40386]
∅:D[8.40386] → [2.61171:61316]
∅:D[25.15552] → [7.8623:8703]
∅:D[9.23902] → [7.8623:8703]
∅:D[27.11313] → [7.8623:8703]
∅:D[4.18317] → [7.8623:8703]
∅:D[2.61316] → [7.8623:8703]
∅:D[33.5336] → [7.8623:8703]
∅:D[35.4331] → [7.8623:8703]
∅:D[26.16359] → [7.8623:8703]
∅:D[10.18061] → [7.8623:8703]
∅:D[34.8031] → [7.8623:8703]
∅:D[12.8723] → [7.8623:8703]
∅:D[36.2776] → [7.8623:8703]
∅:D[8.40531] → [7.8623:8703]
∅:D[7.8623] → [7.8623:8703]
∅:D[14.5515] → [6.17657:18151]
∅:D[7.8703] → [6.17657:18151]
∅:D[6.17657] → [6.17657:18151]
∅:D[6.18151] → [8.40532:40651]
∅:D[9.24022] → [6.18151:18854]
∅:D[8.40651] → [6.18151:18854]
∅:D[6.18151] → [6.18151:18854]
∅:D[6.18854] → [8.40652:40740]
∅:D[37.374] → [6.18942:18974]
∅:D[25.15641] → [6.18942:18974]
∅:D[27.11402] → [6.18942:18974]
∅:D[4.18406] → [6.18942:18974]
∅:D[26.16448] → [6.18942:18974]
∅:D[34.8120] → [6.18942:18974]
∅:D[38.4465] → [6.18942:18974]
∅:D[36.2865] → [6.18942:18974]
∅:D[8.40740] → [6.18942:18974]
∅:D[6.18942] → [6.18942:18974]
∅:D[6.18974] → [2.61317:61336]
∅:D[25.15661] → [6.18993:19196]
∅:D[4.18426] → [6.18993:19196]
∅:D[2.61336] → [6.18993:19196]
∅:D[8.40760] → [6.18993:19196]
∅:D[6.18993] → [6.18993:19196]
∅:D[6.19196] → [2.61337:61412]
∅:D[2.61412] → [8.40836:40912]
∅:D[8.40836] → [8.40836:40912]
∅:D[37.451] → [6.19346:19384]
∅:D[18.18222] → [6.19346:19384]
∅:D[25.15813] → [6.19346:19384]
∅:D[9.24098] → [6.19346:19384]
∅:D[27.11478] → [6.19346:19384]
∅:D[14.5591] → [6.19346:19384]
∅:D[15.3125] → [6.19346:19384]
∅:D[4.18577] → [6.19346:19384]
∅:D[26.16525] → [6.19346:19384]
∅:D[20.12138] → [6.19346:19384]
∅:D[10.18137] → [6.19346:19384]
∅:D[29.10005] → [6.19346:19384]
∅:D[21.35898] → [6.19346:19384]
∅:D[11.12138] → [6.19346:19384]
∅:D[39.7255] → [6.19346:19384]
∅:D[22.4777] → [6.19346:19384]
∅:D[31.15444] → [6.19346:19384]
∅:D[34.8196] → [6.19346:19384]
∅:D[12.8799] → [6.19346:19384]
∅:D[23.6738] → [6.19346:19384]
∅:D[38.4541] → [6.19346:19384]
∅:D[36.2942] → [6.19346:19384]
∅:D[24.7534] → [6.19346:19384]
∅:D[8.40912] → [6.19346:19384]
∅:D[6.19346] → [6.19346:19384]
∅:D[6.19384] → [8.40913:40932]
∅:D[18.18242] → [6.19402:19586]
∅:D[9.24118] → [6.19402:19586]
∅:D[14.5610] → [6.19402:19586]
∅:D[4.18596] → [6.19402:19586]
∅:D[10.18157] → [6.19402:19586]
∅:D[21.35918] → [6.19402:19586]
∅:D[11.12157] → [6.19402:19586]
∅:D[12.8818] → [6.19402:19586]
∅:D[8.40932] → [6.19402:19586]
∅:D[6.19402] → [6.19402:19586]
∅:D[6.19586] → [2.61413:61432]
∅:D[18.18262] → [6.19605:19687]
∅:D[25.15833] → [6.19605:19687]
∅:D[9.24138] → [6.19605:19687]
∅:D[27.11498] → [6.19605:19687]
∅:D[14.5630] → [6.19605:19687]
∅:D[4.18616] → [6.19605:19687]
∅:D[2.61432] → [6.19605:19687]
∅:D[35.4351] → [6.19605:19687]
∅:D[10.18177] → [6.19605:19687]
∅:D[21.35938] → [6.19605:19687]
∅:D[11.12177] → [6.19605:19687]
∅:D[12.8838] → [6.19605:19687]
∅:D[7.8723] → [6.19605:19687]
∅:D[8.40952] → [6.19605:19687]
∅:D[6.19605] → [6.19605:19687]
∅:D[6.19687] → [8.40953:41029]
∅:D[8.41029] → [2.61433:61506]
∅:D[25.15907] → [6.19836:19906]
∅:D[27.11572] → [6.19836:19906]
∅:D[14.5780] → [6.19836:19906]
∅:D[4.18766] → [6.19836:19906]
∅:D[2.61506] → [6.19836:19906]
∅:D[33.5410] → [6.19836:19906]
∅:D[35.4425] → [6.19836:19906]
∅:D[36.3016] → [6.19836:19906]
∅:D[7.8797] → [6.19836:19906]
∅:D[8.41102] → [6.19836:19906]
∅:D[6.19836] → [6.19836:19906]
∅:D[6.19906] → [2.61507:61654]
∅:D[25.16055] → [6.20053:20128]
∅:D[9.24288] → [6.20053:20128]
∅:D[27.11645] → [6.20053:20128]
∅:D[14.5853] → [6.20053:20128]
∅:D[4.18914] → [6.20053:20128]
∅:D[2.61654] → [6.20053:20128]
∅:D[26.16598] → [6.20053:20128]
∅:D[34.8269] → [6.20053:20128]
∅:D[36.3089] → [6.20053:20128]
∅:D[7.8870] → [6.20053:20128]
∅:D[8.41250] → [6.20053:20128]
∅:D[6.20053] → [6.20053:20128]
∅:D[6.20128] → [7.8871:8941]
∅:D[7.8941] → [8.41251:41750]
∅:D[9.24788] → [10.18475:18490]
∅:D[4.19135] → [10.18475:18490]
∅:D[12.9136] → [10.18475:18490]
∅:D[8.41750] → [10.18475:18490]
∅:D[10.18475] → [10.18475:18490]
∅:D[6.20433] → [6.20433:20551]
∅:D[6.20551] → [2.61655:61727]
∅:D[18.18912] → [6.20623:20726]
∅:D[25.16205] → [6.20623:20726]
∅:D[9.24861] → [6.20623:20726]
∅:D[27.11795] → [6.20623:20726]
∅:D[14.6217] → [6.20623:20726]
∅:D[15.3198] → [6.20623:20726]
∅:D[4.19208] → [6.20623:20726]
∅:D[2.61727] → [6.20623:20726]
∅:D[33.5483] → [6.20623:20726]
∅:D[35.4498] → [6.20623:20726]
∅:D[26.16748] → [6.20623:20726]
∅:D[20.12211] → [6.20623:20726]
∅:D[10.18827] → [6.20623:20726]
∅:D[29.10078] → [6.20623:20726]
∅:D[21.36588] → [6.20623:20726]
∅:D[11.12548] → [6.20623:20726]
∅:D[39.7328] → [6.20623:20726]
∅:D[22.4850] → [6.20623:20726]
∅:D[31.15517] → [6.20623:20726]
∅:D[34.8419] → [6.20623:20726]
∅:D[12.9209] → [6.20623:20726]
∅:D[23.6811] → [6.20623:20726]
∅:D[36.3239] → [6.20623:20726]
∅:D[24.7607] → [6.20623:20726]
∅:D[7.9088] → [6.20623:20726]
∅:D[8.41823] → [6.20623:20726]
∅:D[6.20623] → [6.20623:20726]
∅:D[6.20726] → [2.61728:61747]
∅:D[25.16225] → [6.20745:20827]
∅:D[9.24881] → [6.20745:20827]
∅:D[27.11815] → [6.20745:20827]
∅:D[14.6237] → [6.20745:20827]
∅:D[4.19228] → [6.20745:20827]
∅:D[2.61747] → [6.20745:20827]
∅:D[26.16768] → [6.20745:20827]
∅:D[34.8439] → [6.20745:20827]
∅:D[36.3259] → [6.20745:20827]
∅:D[7.9108] → [6.20745:20827]
∅:D[8.41843] → [6.20745:20827]
∅:D[6.20745] → [6.20745:20827]
∅:D[6.20827] → [2.61748:61821]
∅:D[25.16299] → [6.20900:21092]
∅:D[27.11889] → [6.20900:21092]
∅:D[14.6311] → [6.20900:21092]
∅:D[4.19302] → [6.20900:21092]
∅:D[2.61821] → [6.20900:21092]
∅:D[33.5557] → [6.20900:21092]
∅:D[35.4572] → [6.20900:21092]
∅:D[36.3333] → [6.20900:21092]
∅:D[7.9182] → [6.20900:21092]
∅:D[8.41917] → [6.20900:21092]
∅:D[6.20900] → [6.20900:21092]
∅:D[6.21092] → [7.9183:9298]
∅:D[7.9298] → [6.21092:21157]
∅:D[6.21092] → [6.21092:21157]
∅:D[6.21157] → [7.9299:9396]
∅:D[7.9396] → [6.21157:21170]
∅:D[6.21157] → [6.21157:21170]
∅:D[6.21382] → [6.21382:21397]
∅:D[6.21397] → [2.61822:61842]
∅:D[37.472] → [6.21417:21499]
∅:D[18.18933] → [6.21417:21499]
∅:D[25.16320] → [6.21417:21499]
∅:D[9.24902] → [6.21417:21499]
∅:D[27.11910] → [6.21417:21499]
∅:D[14.6332] → [6.21417:21499]
∅:D[15.3219] → [6.21417:21499]
∅:D[4.19323] → [6.21417:21499]
∅:D[2.61842] → [6.21417:21499]
∅:D[26.16789] → [6.21417:21499]
∅:D[20.12232] → [6.21417:21499]
∅:D[10.18848] → [6.21417:21499]
∅:D[29.10099] → [6.21417:21499]
∅:D[21.36609] → [6.21417:21499]
∅:D[11.12569] → [6.21417:21499]
∅:D[39.7349] → [6.21417:21499]
∅:D[22.4871] → [6.21417:21499]
∅:D[31.15538] → [6.21417:21499]
∅:D[34.8460] → [6.21417:21499]
∅:D[12.9230] → [6.21417:21499]
∅:D[23.6832] → [6.21417:21499]
∅:D[38.4562] → [6.21417:21499]
∅:D[36.3354] → [6.21417:21499]
∅:D[24.7628] → [6.21417:21499]
∅:D[7.9417] → [6.21417:21499]
∅:D[8.41938] → [6.21417:21499]
∅:D[6.21417] → [6.21417:21499]
∅:D[6.21499] → [2.61843:61991]
∅:D[25.16469] → [6.21647:21729]
∅:D[4.19472] → [6.21647:21729]
∅:D[2.61991] → [6.21647:21729]
∅:D[8.42087] → [6.21647:21729]
∅:D[6.21647] → [6.21647:21729]
∅:D[6.21729] → [2.61992:62134]
∅:D[25.16612] → [6.21871:22089]
∅:D[9.25045] → [6.21871:22089]
∅:D[27.12127] → [6.21871:22089]
∅:D[14.6549] → [6.21871:22089]
∅:D[4.19615] → [6.21871:22089]
∅:D[2.62134] → [6.21871:22089]
∅:D[26.16862] → [6.21871:22089]
∅:D[34.8533] → [6.21871:22089]
∅:D[36.3501] → [6.21871:22089]
∅:D[7.9634] → [6.21871:22089]
∅:D[8.42230] → [6.21871:22089]
∅:D[6.21871] → [6.21871:22089]
∅:D[6.22089] → [7.9635:9705]
∅:D[14.6620] → [6.22159:22231]
∅:D[7.9705] → [6.22159:22231]
∅:D[6.22159] → [6.22159:22231]
∅:D[6.22231] → [8.42231:42383]
∅:D[8.42383] → [2.62135:62289]
∅:D[2.62289] → [8.42537:42769]
∅:D[8.42537] → [8.42537:42769]
∅:D[8.42769] → [2.62290:62374]
∅:D[2.62374] → [8.42853:42932]
∅:D[8.42853] → [8.42853:42932]
∅:D[9.25667] → [6.22850:23203]
∅:D[14.7240] → [6.22850:23203]
∅:D[4.20235] → [6.22850:23203]
∅:D[7.10022] → [6.22850:23203]
∅:D[8.42932] → [6.22850:23203]
∅:D[6.22850] → [6.22850:23203]
∅:D[6.23203] → [8.42933:43021]
∅:D[9.25756] → [6.23291:23535]
∅:D[4.20324] → [6.23291:23535]
∅:D[8.43021] → [6.23291:23535]
∅:D[6.23291] → [6.23291:23535]
∅:D[6.23535] → [2.62375:62447]
∅:D[18.19620] → [6.23607:23713]
∅:D[25.17162] → [6.23607:23713]
∅:D[9.25829] → [6.23607:23713]
∅:D[27.12516] → [6.23607:23713]
∅:D[14.7313] → [6.23607:23713]
∅:D[15.3365] → [6.23607:23713]
∅:D[4.20397] → [6.23607:23713]
∅:D[2.62447] → [6.23607:23713]
∅:D[33.5704] → [6.23607:23713]
∅:D[35.4864] → [6.23607:23713]
∅:D[26.17332] → [6.23607:23713]
∅:D[20.12378] → [6.23607:23713]
∅:D[10.19535] → [6.23607:23713]
∅:D[29.10245] → [6.23607:23713]
∅:D[21.37296] → [6.23607:23713]
∅:D[11.13255] → [6.23607:23713]
∅:D[39.7495] → [6.23607:23713]
∅:D[22.5017] → [6.23607:23713]
∅:D[31.15684] → [6.23607:23713]
∅:D[34.8922] → [6.23607:23713]
∅:D[12.9916] → [6.23607:23713]
∅:D[23.6978] → [6.23607:23713]
∅:D[36.3971] → [6.23607:23713]
∅:D[24.7774] → [6.23607:23713]
∅:D[7.10095] → [6.23607:23713]
∅:D[8.43094] → [6.23607:23713]
∅:D[6.23607] → [6.23607:23713]
∅:D[6.23713] → [7.10096:10114]
∅:D[14.7332] → [6.23731:24042]
∅:D[7.10114] → [6.23731:24042]
∅:D[6.23731] → [6.23731:24042]
∅:D[6.24042] → [2.62448:62521]
∅:D[25.17236] → [6.24115:24326]
∅:D[4.20471] → [6.24115:24326]
∅:D[2.62521] → [6.24115:24326]
∅:D[8.43168] → [6.24115:24326]
∅:D[6.24115] → [6.24115:24326]
∅:D[6.24326] → [8.43169:43187]
∅:D[18.19639] → [6.24344:24426]
∅:D[9.25848] → [6.24344:24426]
∅:D[14.7351] → [6.24344:24426]
∅:D[4.20490] → [6.24344:24426]
∅:D[10.19554] → [6.24344:24426]
∅:D[21.37315] → [6.24344:24426]
∅:D[11.13274] → [6.24344:24426]
∅:D[12.9935] → [6.24344:24426]
∅:D[8.43187] → [6.24344:24426]
∅:D[6.24344] → [6.24344:24426]
∅:D[6.24426] → [8.43188:43418]
∅:D[18.19870] → [6.24655:25092]
∅:D[9.26079] → [6.24655:25092]
∅:D[14.7581] → [6.24655:25092]
∅:D[4.20720] → [6.24655:25092]
∅:D[10.19785] → [6.24655:25092]
∅:D[21.37546] → [6.24655:25092]
∅:D[11.13504] → [6.24655:25092]
∅:D[12.10165] → [6.24655:25092]
∅:D[8.43418] → [6.24655:25092]
∅:D[6.24655] → [6.24655:25092]
∅:D[6.25092] → [8.43419:43437]
∅:D[25.17255] → [6.25110:25175]
∅:D[27.12535] → [6.25110:25175]
∅:D[14.7600] → [6.25110:25175]
∅:D[4.20739] → [6.25110:25175]
∅:D[26.17351] → [6.25110:25175]
∅:D[34.8941] → [6.25110:25175]
∅:D[36.3990] → [6.25110:25175]
∅:D[7.10133] → [6.25110:25175]
∅:D[8.43437] → [6.25110:25175]
∅:D[6.25110] → [6.25110:25175]
∅:D[14.7700] → [6.25175:25206]
∅:D[6.25175] → [6.25175:25206]
∅:D[6.25206] → [7.10134:10152]
∅:D[14.7719] → [6.25224:25316]
∅:D[7.10152] → [6.25224:25316]
∅:D[6.25224] → [6.25224:25316]
∅:D[6.25316] → [2.62522:62541]
∅:D[18.19890] → [6.25335:25438]
∅:D[25.17275] → [6.25335:25438]
∅:D[9.26099] → [6.25335:25438]
∅:D[27.12555] → [6.25335:25438]
∅:D[14.7739] → [6.25335:25438]
∅:D[15.3385] → [6.25335:25438]
∅:D[4.20759] → [6.25335:25438]
∅:D[2.62541] → [6.25335:25438]
∅:D[33.5724] → [6.25335:25438]
∅:D[35.4884] → [6.25335:25438]
∅:D[26.17371] → [6.25335:25438]
∅:D[20.12398] → [6.25335:25438]
∅:D[10.19805] → [6.25335:25438]
∅:D[29.10421] → [6.25335:25438]
∅:D[21.37566] → [6.25335:25438]
∅:D[11.13524] → [6.25335:25438]
∅:D[39.7515] → [6.25335:25438]
∅:D[22.5037] → [6.25335:25438]
∅:D[31.15704] → [6.25335:25438]
∅:D[34.8961] → [6.25335:25438]
∅:D[12.10185] → [6.25335:25438]
∅:D[23.7154] → [6.25335:25438]
∅:D[36.4010] → [6.25335:25438]
∅:D[24.7794] → [6.25335:25438]
∅:D[7.10172] → [6.25335:25438]
∅:D[8.43457] → [6.25335:25438]
∅:D[6.25335] → [6.25335:25438]
∅:D[6.25438] → [2.62542:62560]
∅:D[25.17294] → [6.25456:25552]
∅:D[27.12574] → [6.25456:25552]
∅:D[4.20778] → [6.25456:25552]
∅:D[2.62560] → [6.25456:25552]
∅:D[35.4903] → [6.25456:25552]
∅:D[8.43476] → [6.25456:25552]
∅:D[6.25456] → [6.25456:25552]
∅:D[6.25552] → [7.10173:10191]
∅:D[14.7758] → [6.25570:25652]
∅:D[7.10191] → [6.25570:25652]
∅:D[6.25570] → [6.25570:25652]
∅:D[6.25652] → [7.10192:10269]
∅:D[14.7836] → [6.25729:25806]
∅:D[7.10269] → [6.25729:25806]
∅:D[6.25729] → [6.25729:25806]
∅:D[14.8007] → [14.8007:8035]
∅:D[14.8035] → [7.10270:10288]
∅:D[14.8053] → [6.25852:25934]
∅:D[7.10288] → [6.25852:25934]
∅:D[6.25852] → [6.25852:25934]
∅:D[6.25934] → [2.62561:62634]
∅:D[25.17368] → [6.26007:26041]
∅:D[27.12648] → [6.26007:26041]
∅:D[4.20852] → [6.26007:26041]
∅:D[2.62634] → [6.26007:26041]
∅:D[33.5798] → [6.26007:26041]
∅:D[35.4977] → [6.26007:26041]
∅:D[36.4084] → [6.26007:26041]
∅:D[8.43550] → [6.26007:26041]
∅:D[6.26007] → [6.26007:26041]
∅:D[6.26041] → [2.62635:62653]
∅:D[25.17387] → [6.26059:26141]
∅:D[27.12667] → [6.26059:26141]
∅:D[4.20871] → [6.26059:26141]
∅:D[2.62653] → [6.26059:26141]
∅:D[35.4996] → [6.26059:26141]
∅:D[8.43569] → [6.26059:26141]
∅:D[6.26059] → [6.26059:26141]
∅:D[6.26141] → [2.62654:62736]
∅:D[25.17470] → [6.26223:26368]
∅:D[27.12750] → [6.26223:26368]
∅:D[4.20954] → [6.26223:26368]
∅:D[2.62736] → [6.26223:26368]
∅:D[35.5079] → [6.26223:26368]
∅:D[8.43652] → [6.26223:26368]
∅:D[6.26223] → [6.26223:26368]
∅:D[6.26368] → [8.43653:43671]
∅:D[18.19909] → [6.26386:26468]
∅:D[9.26118] → [6.26386:26468]
∅:D[14.8072] → [6.26386:26468]
∅:D[15.3404] → [6.26386:26468]
∅:D[4.20973] → [6.26386:26468]
∅:D[20.12417] → [6.26386:26468]
∅:D[10.19824] → [6.26386:26468]
∅:D[29.10440] → [6.26386:26468]
∅:D[21.37585] → [6.26386:26468]
∅:D[11.13543] → [6.26386:26468]
∅:D[39.7534] → [6.26386:26468]
∅:D[22.5056] → [6.26386:26468]
∅:D[31.15723] → [6.26386:26468]
∅:D[12.10204] → [6.26386:26468]
∅:D[23.7173] → [6.26386:26468]
∅:D[24.7813] → [6.26386:26468]
∅:D[8.43671] → [6.26386:26468]
∅:D[6.26386] → [6.26386:26468]
∅:D[6.26468] → [8.43672:43822]
∅:D[8.43822] → [2.62737:62890]
∅:D[2.62890] → [8.43975:44053]
∅:D[8.43975] → [8.43975:44053]
∅:D[18.20291] → [6.26849:27015]
∅:D[25.17702] → [6.26849:27015]
∅:D[9.26500] → [6.26849:27015]
∅:D[27.12982] → [6.26849:27015]
∅:D[13.8632] → [6.26849:27015]
∅:D[14.8454] → [6.26849:27015]
∅:D[4.21355] → [6.26849:27015]
∅:D[26.17603] → [6.26849:27015]
∅:D[10.20206] → [6.26849:27015]
∅:D[21.37967] → [6.26849:27015]
∅:D[11.13925] → [6.26849:27015]
∅:D[31.15955] → [6.26849:27015]
∅:D[34.9193] → [6.26849:27015]
∅:D[12.10586] → [6.26849:27015]
∅:D[36.4316] → [6.26849:27015]
∅:D[7.10367] → [6.26849:27015]
∅:D[8.44053] → [6.26849:27015]
∅:D[6.26849] → [6.26849:27015]
∅:D[6.27015] → [8.44054:44128]
∅:D[18.20366] → [6.27089:27233]
∅:D[9.26575] → [6.27089:27233]
∅:D[14.8529] → [6.27089:27233]
∅:D[15.3633] → [6.27089:27233]
∅:D[4.21430] → [6.27089:27233]
∅:D[20.12646] → [6.27089:27233]
∅:D[10.20281] → [6.27089:27233]
∅:D[29.10669] → [6.27089:27233]
∅:D[21.38042] → [6.27089:27233]
∅:D[11.14000] → [6.27089:27233]
∅:D[39.7763] → [6.27089:27233]
∅:D[22.5285] → [6.27089:27233]
∅:D[31.16030] → [6.27089:27233]
∅:D[12.10661] → [6.27089:27233]
∅:D[23.7402] → [6.27089:27233]
∅:D[24.8042] → [6.27089:27233]
∅:D[8.44128] → [6.27089:27233]
∅:D[6.27089] → [6.27089:27233]
∅:D[6.27233] → [8.44129:44147]
∅:D[37.645] → [6.27251:27316]
∅:D[18.20385] → [6.27251:27316]
∅:D[25.17721] → [6.27251:27316]
∅:D[9.26594] → [6.27251:27316]
∅:D[27.13001] → [6.27251:27316]
∅:D[14.8548] → [6.27251:27316]
∅:D[15.3652] → [6.27251:27316]
∅:D[4.21449] → [6.27251:27316]
∅:D[26.17622] → [6.27251:27316]
∅:D[20.12665] → [6.27251:27316]
∅:D[10.20300] → [6.27251:27316]
∅:D[29.10688] → [6.27251:27316]
∅:D[21.38061] → [6.27251:27316]
∅:D[11.14019] → [6.27251:27316]
∅:D[39.7782] → [6.27251:27316]
∅:D[22.5304] → [6.27251:27316]
∅:D[31.16049] → [6.27251:27316]
∅:D[34.9212] → [6.27251:27316]
∅:D[12.10680] → [6.27251:27316]
∅:D[23.7421] → [6.27251:27316]
∅:D[38.4735] → [6.27251:27316]
∅:D[36.4335] → [6.27251:27316]
∅:D[24.8061] → [6.27251:27316]
∅:D[7.10386] → [6.27251:27316]
∅:D[8.44147] → [6.27251:27316]
∅:D[6.27251] → [6.27251:27316]
∅:D[27.13166] → [6.27560:27705]
∅:D[4.21694] → [6.27560:27705]
∅:D[34.9377] → [6.27560:27705]
∅:D[38.4900] → [6.27560:27705]
∅:D[6.27560] → [6.27560:27705]
∅:D[6.27705] → [8.44148:44167]
∅:D[18.20478] → [6.27723:27805]
∅:D[9.26687] → [6.27723:27805]
∅:D[14.8720] → [6.27723:27805]
∅:D[4.21713] → [6.27723:27805]
∅:D[10.20393] → [6.27723:27805]
∅:D[21.38154] → [6.27723:27805]
∅:D[11.14191] → [6.27723:27805]
∅:D[12.10852] → [6.27723:27805]
∅:D[8.44167] → [6.27723:27805]
∅:D[6.27723] → [6.27723:27805]
∅:D[6.27805] → [8.44168:44400]
∅:D[18.20711] → [6.28037:28483]
∅:D[25.17799] → [6.28037:28483]
∅:D[9.26920] → [6.28037:28483]
∅:D[27.13244] → [6.28037:28483]
∅:D[14.8953] → [6.28037:28483]
∅:D[4.21946] → [6.28037:28483]
∅:D[26.17700] → [6.28037:28483]
∅:D[10.20626] → [6.28037:28483]
∅:D[21.38387] → [6.28037:28483]
∅:D[11.14424] → [6.28037:28483]
∅:D[34.9455] → [6.28037:28483]
∅:D[12.11085] → [6.28037:28483]
∅:D[36.4413] → [6.28037:28483]
∅:D[8.44400] → [6.28037:28483]
∅:D[6.28037] → [6.28037:28483]
∅:D[6.28483] → [7.10460:10535]
∅:D[7.10535] → [2.62891:62963]
∅:D[25.17872] → [7.10607:10677]
∅:D[9.26993] → [7.10607:10677]
∅:D[27.13317] → [7.10607:10677]
∅:D[4.22019] → [7.10607:10677]
∅:D[2.62963] → [7.10607:10677]
∅:D[33.5871] → [7.10607:10677]
∅:D[35.5152] → [7.10607:10677]
∅:D[26.17773] → [7.10607:10677]
∅:D[10.20699] → [7.10607:10677]
∅:D[34.9528] → [7.10607:10677]
∅:D[12.11158] → [7.10607:10677]
∅:D[36.4486] → [7.10607:10677]
∅:D[8.44473] → [7.10607:10677]
∅:D[7.10607] → [7.10607:10677]
∅:D[14.9171] → [6.28700:28843]
∅:D[7.10677] → [6.28700:28843]
∅:D[6.28700] → [6.28700:28843]
∅:D[6.28843] → [8.44474:44545]
∅:D[18.20856] → [6.28914:29191]
∅:D[9.27065] → [6.28914:29191]
∅:D[14.9243] → [6.28914:29191]
∅:D[4.22091] → [6.28914:29191]
∅:D[10.20771] → [6.28914:29191]
∅:D[21.38532] → [6.28914:29191]
∅:D[11.14569] → [6.28914:29191]
∅:D[12.11230] → [6.28914:29191]
∅:D[8.44545] → [6.28914:29191]
∅:D[6.28914] → [6.28914:29191]
∅:D[6.29191] → [2.62964:63036]
∅:D[18.20929] → [6.29263:29899]
∅:D[25.17945] → [6.29263:29899]
∅:D[9.27138] → [6.29263:29899]
∅:D[27.13390] → [6.29263:29899]
∅:D[14.9316] → [6.29263:29899]
∅:D[15.3871] → [6.29263:29899]
∅:D[4.22164] → [6.29263:29899]
∅:D[2.63036] → [6.29263:29899]
∅:D[33.5944] → [6.29263:29899]
∅:D[35.5225] → [6.29263:29899]
∅:D[26.17846] → [6.29263:29899]
∅:D[20.12884] → [6.29263:29899]
∅:D[10.20844] → [6.29263:29899]
∅:D[29.11063] → [6.29263:29899]
∅:D[21.38605] → [6.29263:29899]
∅:D[11.14642] → [6.29263:29899]
∅:D[39.8001] → [6.29263:29899]
∅:D[22.5523] → [6.29263:29899]
∅:D[31.16268] → [6.29263:29899]
∅:D[34.9601] → [6.29263:29899]
∅:D[12.11303] → [6.29263:29899]
∅:D[23.7796] → [6.29263:29899]
∅:D[36.4559] → [6.29263:29899]
∅:D[24.8280] → [6.29263:29899]
∅:D[7.10750] → [6.29263:29899]
∅:D[8.44618] → [6.29263:29899]
∅:D[6.29263] → [6.29263:29899]
∅:D[6.29899] → [8.44619:44697]
∅:D[8.44697] → [2.63037:63109]
∅:D[25.18096] → [7.10901:10971]
∅:D[9.27211] → [7.10901:10971]
∅:D[27.13541] → [7.10901:10971]
∅:D[4.22315] → [7.10901:10971]
∅:D[2.63109] → [7.10901:10971]
∅:D[33.6017] → [7.10901:10971]
∅:D[35.5298] → [7.10901:10971]
∅:D[26.17997] → [7.10901:10971]
∅:D[10.20917] → [7.10901:10971]
∅:D[34.9752] → [7.10901:10971]
∅:D[12.11376] → [7.10901:10971]
∅:D[36.4710] → [7.10901:10971]
∅:D[8.44769] → [7.10901:10971]
∅:D[7.10901] → [7.10901:10971]
∅:D[7.10971] → [2.63110:63186]
∅:D[18.21079] → [6.30195:30275]
∅:D[25.18173] → [6.30195:30275]
∅:D[9.27288] → [6.30195:30275]
∅:D[27.13618] → [6.30195:30275]
∅:D[14.9613] → [6.30195:30275]
∅:D[15.4021] → [6.30195:30275]
∅:D[4.22392] → [6.30195:30275]
∅:D[2.63186] → [6.30195:30275]
∅:D[35.5375] → [6.30195:30275]
∅:D[26.18074] → [6.30195:30275]
∅:D[20.13034] → [6.30195:30275]
∅:D[10.20994] → [6.30195:30275]
∅:D[29.11213] → [6.30195:30275]
∅:D[21.38755] → [6.30195:30275]
∅:D[11.14792] → [6.30195:30275]
∅:D[39.8151] → [6.30195:30275]
∅:D[22.5673] → [6.30195:30275]
∅:D[31.16418] → [6.30195:30275]
∅:D[34.9829] → [6.30195:30275]
∅:D[12.11453] → [6.30195:30275]
∅:D[23.7946] → [6.30195:30275]
∅:D[36.4787] → [6.30195:30275]
∅:D[24.8430] → [6.30195:30275]
∅:D[8.44846] → [6.30195:30275]
∅:D[6.30195] → [6.30195:30275]
∅:D[6.30275] → [2.63187:63266]
∅:D[2.63266] → [8.44926:45251]
∅:D[8.44926] → [8.44926:45251]
∅:D[37.721] → [6.30679:30809]
∅:D[25.18405] → [6.30679:30809]
∅:D[9.27618] → [6.30679:30809]
∅:D[27.13850] → [6.30679:30809]
∅:D[14.9943] → [6.30679:30809]
∅:D[4.22797] → [6.30679:30809]
∅:D[26.18306] → [6.30679:30809]
∅:D[34.10061] → [6.30679:30809]
∅:D[38.4976] → [6.30679:30809]
∅:D[36.5019] → [6.30679:30809]
∅:D[7.11047] → [6.30679:30809]
∅:D[8.45251] → [6.30679:30809]
∅:D[6.30679] → [6.30679:30809]
∅:D[6.30809] → [2.63267:63485]
∅:D[25.18624] → [6.31027:31073]
∅:D[4.23016] → [6.31027:31073]
∅:D[2.63485] → [6.31027:31073]
∅:D[8.45470] → [6.31027:31073]
∅:D[6.31027] → [6.31027:31073]
∅:D[6.31073] → [8.45471:45489]
∅:D[37.740] → [6.31091:31156]
∅:D[25.18643] → [6.31091:31156]
∅:D[27.14015] → [6.31091:31156]
∅:D[4.23035] → [6.31091:31156]
∅:D[26.18398] → [6.31091:31156]
∅:D[34.10153] → [6.31091:31156]
∅:D[38.4995] → [6.31091:31156]
∅:D[36.5184] → [6.31091:31156]
∅:D[8.45489] → [6.31091:31156]
∅:D[6.31091] → [6.31091:31156]
∅:D[27.14113] → [6.31253:31282]
∅:D[4.23133] → [6.31253:31282]
∅:D[34.10251] → [6.31253:31282]
∅:D[38.5093] → [6.31253:31282]
∅:D[6.31253] → [6.31253:31282]
∅:D[6.31282] → [7.11121:11140]
∅:D[14.10036] → [6.31301:31727]
∅:D[7.11140] → [6.31301:31727]
∅:D[6.31301] → [6.31301:31727]
∅:D[6.31727] → [8.45490:45509]
∅:D[37.760] → [6.31745:31827]
∅:D[18.21426] → [6.31745:31827]
∅:D[25.18663] → [6.31745:31827]
∅:D[9.27710] → [6.31745:31827]
∅:D[27.14132] → [6.31745:31827]
∅:D[14.10055] → [6.31745:31827]
∅:D[15.4283] → [6.31745:31827]
∅:D[4.23152] → [6.31745:31827]
∅:D[26.18418] → [6.31745:31827]
∅:D[20.13296] → [6.31745:31827]
∅:D[10.21341] → [6.31745:31827]
∅:D[29.11475] → [6.31745:31827]
∅:D[21.39102] → [6.31745:31827]
∅:D[11.15139] → [6.31745:31827]
∅:D[39.8323] → [6.31745:31827]
∅:D[22.5845] → [6.31745:31827]
∅:D[31.16680] → [6.31745:31827]
∅:D[34.10270] → [6.31745:31827]
∅:D[12.11800] → [6.31745:31827]
∅:D[23.8208] → [6.31745:31827]
∅:D[38.5112] → [6.31745:31827]
∅:D[36.5204] → [6.31745:31827]
∅:D[24.8692] → [6.31745:31827]
∅:D[8.45509] → [6.31745:31827]
∅:D[6.31745] → [6.31745:31827]
∅:D[6.31827] → [2.63486:63558]
∅:D[18.21499] → [6.31899:31901]
∅:D[25.18736] → [6.31899:31901]
∅:D[9.27783] → [6.31899:31901]
∅:D[27.14205] → [6.31899:31901]
∅:D[14.10128] → [6.31899:31901]
∅:D[15.4356] → [6.31899:31901]
∅:D[4.23225] → [6.31899:31901]
∅:D[2.63558] → [6.31899:31901]
∅:D[33.6236] → [6.31899:31901]
∅:D[35.5674] → [6.31899:31901]
∅:D[26.18491] → [6.31899:31901]
∅:D[20.13369] → [6.31899:31901]
∅:D[10.21414] → [6.31899:31901]
∅:D[29.11548] → [6.31899:31901]
∅:D[21.39175] → [6.31899:31901]
∅:D[11.15212] → [6.31899:31901]
∅:D[39.8396] → [6.31899:31901]
∅:D[22.5918] → [6.31899:31901]
∅:D[31.16753] → [6.31899:31901]
∅:D[34.10343] → [6.31899:31901]
∅:D[12.11873] → [6.31899:31901]
∅:D[23.8281] → [6.31899:31901]
∅:D[36.5277] → [6.31899:31901]
∅:D[24.8765] → [6.31899:31901]
∅:D[7.11213] → [6.31899:31901]
∅:D[8.45582] → [6.31899:31901]
∅:D[6.31899] → [6.31899:31901]
∅:D[6.31901] → [8.45583:45701]
∅:D[9.27902] → [21.39281:39294]
∅:D[8.45701] → [21.39281:39294]
∅:D[21.39281] → [21.39281:39294]
∅:D[18.21618] → [6.31914:31931]
∅:D[10.21533] → [6.31914:31931]
∅:D[21.39294] → [6.31914:31931]
∅:D[6.31914] → [6.31914:31931]
∅:D[6.31931] → [2.63559:63579]
∅:D[18.21639] → [6.31951:32108]
∅:D[25.18757] → [6.31951:32108]
∅:D[9.27923] → [6.31951:32108]
∅:D[27.14226] → [6.31951:32108]
∅:D[14.10149] → [6.31951:32108]
∅:D[15.4377] → [6.31951:32108]
∅:D[4.23246] → [6.31951:32108]
∅:D[2.63579] → [6.31951:32108]
∅:D[35.5695] → [6.31951:32108]
∅:D[26.18512] → [6.31951:32108]
∅:D[20.13390] → [6.31951:32108]
∅:D[10.21554] → [6.31951:32108]
∅:D[29.11569] → [6.31951:32108]
∅:D[21.39315] → [6.31951:32108]
∅:D[11.15233] → [6.31951:32108]
∅:D[39.8417] → [6.31951:32108]
∅:D[22.5939] → [6.31951:32108]
∅:D[31.16774] → [6.31951:32108]
∅:D[34.10364] → [6.31951:32108]
∅:D[12.11894] → [6.31951:32108]
∅:D[23.8302] → [6.31951:32108]
∅:D[36.5298] → [6.31951:32108]
∅:D[24.8786] → [6.31951:32108]
∅:D[8.45722] → [6.31951:32108]
∅:D[6.31951] → [6.31951:32108]
∅:D[6.32108] → [2.63580:63653]
∅:D[25.18831] → [6.32181:32261]
∅:D[27.14300] → [6.32181:32261]
∅:D[4.23320] → [6.32181:32261]
∅:D[2.63653] → [6.32181:32261]
∅:D[33.6310] → [6.32181:32261]
∅:D[35.5769] → [6.32181:32261]
∅:D[36.5372] → [6.32181:32261]
∅:D[8.45796] → [6.32181:32261]
∅:D[6.32181] → [6.32181:32261]
∅:D[6.32261] → [8.45797:45875]
∅:D[8.45875] → [2.63654:63805]
∅:D[18.21791] → [6.32490:32645]
∅:D[25.19061] → [6.32490:32645]
∅:D[9.28075] → [6.32490:32645]
∅:D[27.14530] → [6.32490:32645]
∅:D[14.10379] → [6.32490:32645]
∅:D[15.4529] → [6.32490:32645]
∅:D[4.23550] → [6.32490:32645]
∅:D[2.63805] → [6.32490:32645]
∅:D[35.5921] → [6.32490:32645]
∅:D[26.18742] → [6.32490:32645]
∅:D[20.13542] → [6.32490:32645]
∅:D[10.21706] → [6.32490:32645]
∅:D[29.11721] → [6.32490:32645]
∅:D[21.39467] → [6.32490:32645]
∅:D[11.15385] → [6.32490:32645]
∅:D[39.8569] → [6.32490:32645]
∅:D[22.6091] → [6.32490:32645]
∅:D[31.16926] → [6.32490:32645]
∅:D[34.10594] → [6.32490:32645]
∅:D[12.12046] → [6.32490:32645]
∅:D[23.8454] → [6.32490:32645]
∅:D[36.5602] → [6.32490:32645]
∅:D[24.8938] → [6.32490:32645]
∅:D[8.46026] → [6.32490:32645]
∅:D[6.32490] → [6.32490:32645]
∅:D[6.32645] → [2.63806:63825]
∅:D[18.21811] → [6.32664:32746]
∅:D[25.19081] → [6.32664:32746]
∅:D[9.28095] → [6.32664:32746]
∅:D[27.14550] → [6.32664:32746]
∅:D[14.10399] → [6.32664:32746]
∅:D[15.4549] → [6.32664:32746]
∅:D[4.23570] → [6.32664:32746]
∅:D[2.63825] → [6.32664:32746]
∅:D[35.5941] → [6.32664:32746]
∅:D[26.18762] → [6.32664:32746]
∅:D[20.13562] → [6.32664:32746]
∅:D[10.21726] → [6.32664:32746]
∅:D[29.11741] → [6.32664:32746]
∅:D[21.39487] → [6.32664:32746]
∅:D[11.15405] → [6.32664:32746]
∅:D[39.8589] → [6.32664:32746]
∅:D[22.6111] → [6.32664:32746]
∅:D[31.16946] → [6.32664:32746]
∅:D[34.10614] → [6.32664:32746]
∅:D[12.12066] → [6.32664:32746]
∅:D[23.8474] → [6.32664:32746]
∅:D[36.5622] → [6.32664:32746]
∅:D[24.8958] → [6.32664:32746]
∅:D[8.46046] → [6.32664:32746]
∅:D[6.32664] → [6.32664:32746]
∅:D[6.32746] → [2.63826:63968]
∅:D[18.21954] → [6.32888:32966]
∅:D[25.19224] → [6.32888:32966]
∅:D[9.28238] → [6.32888:32966]
∅:D[27.14693] → [6.32888:32966]
∅:D[14.10542] → [6.32888:32966]
∅:D[15.4692] → [6.32888:32966]
∅:D[4.23713] → [6.32888:32966]
∅:D[2.63968] → [6.32888:32966]
∅:D[33.6456] → [6.32888:32966]
∅:D[35.6084] → [6.32888:32966]
∅:D[26.18905] → [6.32888:32966]
∅:D[20.13705] → [6.32888:32966]
∅:D[10.21869] → [6.32888:32966]
∅:D[29.11884] → [6.32888:32966]
∅:D[21.39630] → [6.32888:32966]
∅:D[11.15548] → [6.32888:32966]
∅:D[39.8732] → [6.32888:32966]
∅:D[22.6254] → [6.32888:32966]
∅:D[31.17089] → [6.32888:32966]
∅:D[34.10757] → [6.32888:32966]
∅:D[12.12209] → [6.32888:32966]
∅:D[23.8617] → [6.32888:32966]
∅:D[36.5765] → [6.32888:32966]
∅:D[24.9101] → [6.32888:32966]
∅:D[7.11437] → [6.32888:32966]
∅:D[8.46189] → [6.32888:32966]
∅:D[6.32888] → [6.32888:32966]
∅:D[6.32966] → [8.46190:46270]
∅:D[25.19305] → [6.32966:33073]
∅:D[26.18986] → [6.32966:33073]
∅:D[36.5846] → [6.32966:33073]
∅:D[8.46270] → [6.32966:33073]
∅:D[6.32966] → [6.32966:33073]
∅:D[6.33073] → [7.11438:11456]
∅:D[14.10561] → [6.33091:33294]
∅:D[7.11456] → [6.33091:33294]
∅:D[6.33091] → [6.33091:33294]
∅:D[6.33294] → [8.46271:46289]
∅:D[18.21973] → [6.33312:33394]
∅:D[9.28257] → [6.33312:33394]
∅:D[14.10580] → [6.33312:33394]
∅:D[4.23732] → [6.33312:33394]
∅:D[10.21888] → [6.33312:33394]
∅:D[21.39649] → [6.33312:33394]
∅:D[11.15567] → [6.33312:33394]
∅:D[12.12228] → [6.33312:33394]
∅:D[8.46289] → [6.33312:33394]
∅:D[6.33312] → [6.33312:33394]
∅:D[6.33394] → [7.11457:11532]
∅:D[7.11532] → [8.46290:46373]
∅:D[18.22057] → [6.33552:33593]
∅:D[9.28341] → [6.33552:33593]
∅:D[14.10739] → [6.33552:33593]
∅:D[4.23816] → [6.33552:33593]
∅:D[10.21972] → [6.33552:33593]
∅:D[21.39733] → [6.33552:33593]
∅:D[11.15651] → [6.33552:33593]
∅:D[12.12312] → [6.33552:33593]
∅:D[8.46373] → [6.33552:33593]
∅:D[6.33552] → [6.33552:33593]
∅:D[6.33593] → [8.46374:46392]
∅:D[18.22076] → [6.33611:33693]
∅:D[9.28360] → [6.33611:33693]
∅:D[14.10758] → [6.33611:33693]
∅:D[4.23835] → [6.33611:33693]
∅:D[10.21991] → [6.33611:33693]
∅:D[21.39752] → [6.33611:33693]
∅:D[11.15670] → [6.33611:33693]
∅:D[12.12331] → [6.33611:33693]
∅:D[8.46392] → [6.33611:33693]
∅:D[6.33611] → [6.33611:33693]
∅:D[6.33693] → [2.63969:64041]
∅:D[2.64041] → [8.46465:46536]
∅:D[8.46465] → [8.46465:46536]
∅:D[18.22220] → [6.33836:33916]
∅:D[9.28504] → [6.33836:33916]
∅:D[14.10902] → [6.33836:33916]
∅:D[4.23979] → [6.33836:33916]
∅:D[10.22135] → [6.33836:33916]
∅:D[21.39896] → [6.33836:33916]
∅:D[11.15814] → [6.33836:33916]
∅:D[12.12475] → [6.33836:33916]
∅:D[8.46536] → [6.33836:33916]
∅:D[6.33836] → [6.33836:33916]
∅:D[6.33916] → [8.46537:46612]
∅:D[8.46612] → [2.64042:64115]
∅:D[2.64115] → [8.46685:46969]
∅:D[8.46685] → [8.46685:46969]
∅:D[9.28865] → [21.40242:40257]
∅:D[4.24128] → [21.40242:40257]
∅:D[8.46969] → [21.40242:40257]
∅:D[21.40242] → [21.40242:40257]
∅:D[18.22581] → [6.34079:34214]
∅:D[10.22496] → [6.34079:34214]
∅:D[21.40257] → [6.34079:34214]
∅:D[6.34079] → [6.34079:34214]
∅:D[6.34214] → [8.46970:46989]
∅:D[18.22601] → [6.34233:34315]
∅:D[9.28885] → [6.34233:34315]
∅:D[14.10998] → [6.34233:34315]
∅:D[4.24148] → [6.34233:34315]
∅:D[10.22516] → [6.34233:34315]
∅:D[21.40277] → [6.34233:34315]
∅:D[11.15910] → [6.34233:34315]
∅:D[12.12571] → [6.34233:34315]
∅:D[8.46989] → [6.34233:34315]
∅:D[6.34233] → [6.34233:34315]
∅:D[6.34315] → [8.46990:47068]
∅:D[18.22680] → [6.34393:34429]
∅:D[9.28964] → [6.34393:34429]
∅:D[14.11077] → [6.34393:34429]
∅:D[4.24227] → [6.34393:34429]
∅:D[10.22595] → [6.34393:34429]
∅:D[21.40356] → [6.34393:34429]
∅:D[11.15989] → [6.34393:34429]
∅:D[12.12650] → [6.34393:34429]
∅:D[8.47068] → [6.34393:34429]
∅:D[6.34393] → [6.34393:34429]
∅:D[6.34429] → [8.47069:47088]
∅:D[18.22700] → [6.34448:34530]
∅:D[9.28984] → [6.34448:34530]
∅:D[14.11097] → [6.34448:34530]
∅:D[4.24247] → [6.34448:34530]
∅:D[10.22615] → [6.34448:34530]
∅:D[21.40376] → [6.34448:34530]
∅:D[11.16009] → [6.34448:34530]
∅:D[12.12670] → [6.34448:34530]
∅:D[8.47088] → [6.34448:34530]
∅:D[6.34448] → [6.34448:34530]
∅:D[6.34530] → [8.47089:47248]
∅:D[18.22860] → [6.34689:34727]
∅:D[9.29144] → [6.34689:34727]
∅:D[14.11257] → [6.34689:34727]
∅:D[4.24407] → [6.34689:34727]
∅:D[10.22775] → [6.34689:34727]
∅:D[21.40536] → [6.34689:34727]
∅:D[11.16169] → [6.34689:34727]
∅:D[12.12830] → [6.34689:34727]
∅:D[8.47248] → [6.34689:34727]
∅:D[6.34689] → [6.34689:34727]
∅:D[6.34727] → [8.47249:47268]
∅:D[18.22880] → [6.34746:34828]
∅:D[9.29164] → [6.34746:34828]
∅:D[14.11277] → [6.34746:34828]
∅:D[4.24427] → [6.34746:34828]
∅:D[10.22795] → [6.34746:34828]
∅:D[21.40556] → [6.34746:34828]
∅:D[11.16189] → [6.34746:34828]
∅:D[12.12850] → [6.34746:34828]
∅:D[8.47268] → [6.34746:34828]
∅:D[6.34746] → [6.34746:34828]
∅:D[6.34828] → [8.47269:47418]
∅:D[18.23030] → [6.34977:35012]
∅:D[9.29314] → [6.34977:35012]
∅:D[14.11427] → [6.34977:35012]
∅:D[4.24577] → [6.34977:35012]
∅:D[10.22945] → [6.34977:35012]
∅:D[21.40706] → [6.34977:35012]
∅:D[11.16339] → [6.34977:35012]
∅:D[12.13000] → [6.34977:35012]
∅:D[8.47418] → [6.34977:35012]
∅:D[6.34977] → [6.34977:35012]
∅:D[6.35012] → [8.47419:47438]
∅:D[18.23050] → [6.35031:35464]
∅:D[9.29334] → [6.35031:35464]
∅:D[14.11447] → [6.35031:35464]
∅:D[4.24597] → [6.35031:35464]
∅:D[10.22965] → [6.35031:35464]
∅:D[21.40726] → [6.35031:35464]
∅:D[11.16359] → [6.35031:35464]
∅:D[12.13020] → [6.35031:35464]
∅:D[8.47438] → [6.35031:35464]
∅:D[6.35031] → [6.35031:35464]
∅:D[6.35464] → [8.47439:47458]
∅:D[18.23070] → [6.35483:35794]
∅:D[9.29354] → [6.35483:35794]
∅:D[14.11467] → [6.35483:35794]
∅:D[4.24617] → [6.35483:35794]
∅:D[10.22985] → [6.35483:35794]
∅:D[21.40746] → [6.35483:35794]
∅:D[11.16379] → [6.35483:35794]
∅:D[12.13040] → [6.35483:35794]
∅:D[7.11701] → [6.35483:35794]
∅:D[8.47458] → [6.35483:35794]
∅:D[6.35483] → [6.35483:35794]
∅:D[6.35794] → [8.47459:47478]
∅:D[18.23090] → [6.35813:35895]
∅:D[25.19547] → [6.35813:35895]
∅:D[9.29374] → [6.35813:35895]
∅:D[27.14862] → [6.35813:35895]
∅:D[14.11487] → [6.35813:35895]
∅:D[4.24637] → [6.35813:35895]
∅:D[26.19155] → [6.35813:35895]
∅:D[10.23005] → [6.35813:35895]
∅:D[21.40766] → [6.35813:35895]
∅:D[11.16399] → [6.35813:35895]
∅:D[34.10926] → [6.35813:35895]
∅:D[12.13060] → [6.35813:35895]
∅:D[36.6015] → [6.35813:35895]
∅:D[8.47478] → [6.35813:35895]
∅:D[6.35813] → [6.35813:35895]
∅:D[6.35895] → [8.47479:47632]
∅:D[9.29528] → [7.11782:11852]
∅:D[4.24791] → [7.11782:11852]
∅:D[10.23159] → [7.11782:11852]
∅:D[12.13214] → [7.11782:11852]
∅:D[8.47632] → [7.11782:11852]
∅:D[14.11641] → [7.11782:11852]
∅:D[7.11852] → [8.47633:47706]
∅:D[37.990] → [6.36191:36333]
∅:D[18.23318] → [6.36191:36333]
∅:D[25.19701] → [6.36191:36333]
∅:D[9.29602] → [6.36191:36333]
∅:D[27.15016] → [6.36191:36333]
∅:D[14.11784] → [6.36191:36333]
∅:D[15.4995] → [6.36191:36333]
∅:D[4.24865] → [6.36191:36333]
∅:D[26.19309] → [6.36191:36333]
∅:D[20.14008] → [6.36191:36333]
∅:D[10.23233] → [6.36191:36333]
∅:D[29.12261] → [6.36191:36333]
∅:D[21.40994] → [6.36191:36333]
∅:D[11.16627] → [6.36191:36333]
∅:D[39.9035] → [6.36191:36333]
∅:D[22.6557] → [6.36191:36333]
∅:D[31.17392] → [6.36191:36333]
∅:D[34.11080] → [6.36191:36333]
∅:D[12.13288] → [6.36191:36333]
∅:D[23.8994] → [6.36191:36333]
∅:D[38.5342] → [6.36191:36333]
∅:D[36.6169] → [6.36191:36333]
∅:D[24.9404] → [6.36191:36333]
∅:D[7.11925] → [6.36191:36333]
∅:D[8.47706] → [6.36191:36333]
∅:D[6.36191] → [6.36191:36333]
∅:D[6.36333] → [2.64116:64135]
∅:D[25.19721] → [12.13435:13517]
∅:D[9.29622] → [12.13435:13517]
∅:D[4.24885] → [12.13435:13517]
∅:D[2.64135] → [12.13435:13517]
∅:D[8.47726] → [12.13435:13517]
∅:D[12.13435] → [12.13435:13517]
∅:D[12.13517] → [8.47727:47806]
∅:D[8.47806] → [4.24965:24994]
∅:D[4.24965] → [4.24965:24994]
∅:D[4.24994] → [8.47807:47825]
∅:D[8.47825] → [4.25012:25094]
∅:D[4.25012] → [4.25012:25094]
∅:D[6.37492] → [14.11995:12070]
∅:D[14.12070] → [8.47826:47906]
∅:D[8.47906] → [2.64136:64208]
∅:D[2.64208] → [8.47978:48054]
∅:D[8.47978] → [8.47978:48054]
∅:D[8.48054] → [2.64209:64282]
∅:D[25.19868] → [7.12245:12274]
∅:D[4.25642] → [7.12245:12274]
∅:D[2.64282] → [7.12245:12274]
∅:D[8.48127] → [7.12245:12274]
∅:D[7.12245] → [7.12245:12274]
∅:D[7.12274] → [8.48128:48146]
∅:D[9.29969] → [7.12292:12374]
∅:D[4.25661] → [7.12292:12374]
∅:D[10.23425] → [7.12292:12374]
∅:D[12.13835] → [7.12292:12374]
∅:D[8.48146] → [7.12292:12374]
∅:D[7.12292] → [7.12292:12374]
∅:D[7.12374] → [8.48147:48221]
∅:D[8.48221] → [2.64283:64355]
∅:D[2.64355] → [8.48293:48447]
∅:D[8.48293] → [8.48293:48447]
∅:D[9.30270] → [7.12756:12907]
∅:D[4.26044] → [7.12756:12907]
∅:D[8.48447] → [7.12756:12907]
∅:D[7.12756] → [7.12756:12907]
∅:D[7.12907] → [8.48448:48526]
∅:D[8.48526] → [2.64356:64430]
∅:D[2.64430] → [8.48600:48755]
∅:D[8.48600] → [8.48600:48755]
∅:D[8.48755] → [2.64431:64504]
∅:D[25.20165] → [7.13143:13179]
∅:D[4.26353] → [7.13143:13179]
∅:D[2.64504] → [7.13143:13179]
∅:D[8.48828] → [7.13143:13179]
∅:D[6.38333] → [7.13143:13179]
∅:D[7.13179] → [8.48829:48847]
∅:D[9.30523] → [7.13197:13279]
∅:D[4.26372] → [7.13197:13279]
∅:D[10.23825] → [7.13197:13279]
∅:D[12.14322] → [7.13197:13279]
∅:D[8.48847] → [7.13197:13279]
∅:D[7.13197] → [7.13197:13279]
∅:D[7.13279] → [8.48848:48998]
∅:D[9.30674] → [6.38333:38348]
∅:D[4.26529] → [6.38333:38348]
∅:D[12.14403] → [6.38333:38348]
∅:D[7.13435] → [6.38333:38348]
∅:D[8.48998] → [6.38333:38348]
∅:D[6.38333] → [6.38333:38348]
∅:D[6.38640] → [6.38640:38659]
∅:D[6.38659] → [8.48999:49017]
∅:D[9.30693] → [6.38677:38759]
∅:D[4.26548] → [6.38677:38759]
∅:D[8.49017] → [6.38677:38759]
∅:D[6.38677] → [6.38677:38759]
∅:D[6.38759] → [8.49018:49094]
∅:D[9.30770] → [6.38835:38869]
∅:D[4.26625] → [6.38835:38869]
∅:D[8.49094] → [6.38835:38869]
∅:D[6.38835] → [6.38835:38869]
∅:D[6.38869] → [8.49095:49113]
∅:D[9.30789] → [7.13436:13631]
∅:D[4.26644] → [7.13436:13631]
∅:D[8.49113] → [7.13436:13631]
∅:D[6.38887] → [7.13436:13631]
∅:D[7.13631] → [8.49114:49190]
∅:D[9.30866] → [7.13707:13742]
∅:D[4.26721] → [7.13707:13742]
∅:D[8.49190] → [7.13707:13742]
∅:D[7.13707] → [7.13707:13742]
∅:D[10.24109] → [7.13742:13760]
∅:D[7.13742] → [7.13742:13760]
∅:D[7.13760] → [6.38887:38952]
∅:D[6.38887] → [6.38887:38952]
∅:D[6.38952] → [7.13761:13778]
∅:D[7.13778] → [8.49191:49403]
∅:D[8.49403] → [2.64505:64577]
∅:D[2.64577] → [8.49475:49551]
∅:D[8.49475] → [8.49475:49551]
∅:D[8.49551] → [2.64578:64651]
∅:D[2.64651] → [8.49624:49656]
∅:D[8.49624] → [8.49624:49656]
∅:D[8.49656] → [2.64652:64670]
∅:D[2.64670] → [8.49674:49911]
∅:D[8.49674] → [8.49674:49911]
∅:D[8.49911] → [2.64671:64743]
∅:D[2.64743] → [8.49983:50132]
∅:D[8.49983] → [8.49983:50132]
∅:D[8.50132] → [2.64744:64817]
∅:D[4.26798] → [9.30943:30958]
∅:D[2.64817] → [9.30943:30958]
∅:D[8.50205] → [9.30943:30958]
∅:D[9.30943] → [9.30943:30958]
∅:D[6.38965] → [7.13857:13875]
∅:D[7.13875] → [8.50206:50494]
∅:D[8.50494] → [4.26799:26817]
∅:D[7.13875] → [4.26799:26817]
∅:D[25.20497] → [7.13893:13975]
∅:D[27.15496] → [7.13893:13975]
∅:D[4.26817] → [7.13893:13975]
∅:D[26.19696] → [7.13893:13975]
∅:D[34.11467] → [7.13893:13975]
∅:D[36.6649] → [7.13893:13975]
∅:D[7.13893] → [7.13893:13975]
∅:D[7.13975] → [8.50495:50571]
∅:D[25.20648] → [7.14131:14146]
∅:D[27.15653] → [7.14131:14146]
∅:D[4.26974] → [7.14131:14146]
∅:D[26.19847] → [7.14131:14146]
∅:D[34.11624] → [7.14131:14146]
∅:D[36.6800] → [7.14131:14146]
∅:D[8.50571] → [7.14131:14146]
∅:D[7.14131] → [7.14131:14146]
∅:D[7.14146] → [8.50572:50606]
∅:D[4.26993] → [9.31977:32059]
∅:D[8.50606] → [9.31977:32059]
∅:D[9.31977] → [9.31977:32059]
∅:D[9.32059] → [8.50607:50683]
∅:D[4.27070] → [9.32135:32150]
∅:D[8.50683] → [9.32135:32150]
∅:D[9.32135] → [9.32135:32150]
∅:D[7.14360] → [6.39887:39910]
∅:D[6.39887] → [6.39887:39910]
∅:D[6.39910] → [2.64818:64837]
∅:D[18.24816] → [6.39929:40048]
∅:D[25.20668] → [6.39929:40048]
∅:D[9.32281] → [6.39929:40048]
∅:D[14.12319] → [6.39929:40048]
∅:D[15.5234] → [6.39929:40048]
∅:D[4.27090] → [6.39929:40048]
∅:D[2.64837] → [6.39929:40048]
∅:D[20.14247] → [6.39929:40048]
∅:D[10.24731] → [6.39929:40048]
∅:D[29.12500] → [6.39929:40048]
∅:D[21.42490] → [6.39929:40048]
∅:D[11.17781] → [6.39929:40048]
∅:D[39.9274] → [6.39929:40048]
∅:D[22.6796] → [6.39929:40048]
∅:D[31.17631] → [6.39929:40048]
∅:D[12.14442] → [6.39929:40048]
∅:D[23.9233] → [6.39929:40048]
∅:D[24.9643] → [6.39929:40048]
∅:D[7.14380] → [6.39929:40048]
∅:D[8.50703] → [6.39929:40048]
∅:D[6.39929] → [6.39929:40048]
∅:D[6.40048] → [7.14381:14463]
∅:D[7.14463] → [2.64838:64919]
∅:D[25.20750] → [7.14544:14574]
∅:D[9.32363] → [7.14544:14574]
∅:D[4.27172] → [7.14544:14574]
∅:D[2.64919] → [7.14544:14574]
∅:D[10.24813] → [7.14544:14574]
∅:D[12.14524] → [7.14544:14574]
∅:D[8.50785] → [7.14544:14574]
∅:D[7.14544] → [7.14544:14574]
∅:D[7.14574] → [2.64920:64938]
∅:D[25.20769] → [7.14592:14674]
∅:D[9.32382] → [7.14592:14674]
∅:D[27.15672] → [7.14592:14674]
∅:D[4.27191] → [7.14592:14674]
∅:D[2.64938] → [7.14592:14674]
∅:D[26.19866] → [7.14592:14674]
∅:D[10.24832] → [7.14592:14674]
∅:D[34.11643] → [7.14592:14674]
∅:D[12.14543] → [7.14592:14674]
∅:D[36.6819] → [7.14592:14674]
∅:D[8.50804] → [7.14592:14674]
∅:D[7.14592] → [7.14592:14674]
∅:D[7.14674] → [2.64939:65019]
∅:D[2.65019] → [8.50884:50957]
∅:D[8.50884] → [8.50884:50957]
∅:D[8.50957] → [2.65020:65099]
∅:D[25.21001] → [7.14905:15099]
∅:D[9.32535] → [7.14905:15099]
∅:D[4.27423] → [7.14905:15099]
∅:D[2.65099] → [7.14905:15099]
∅:D[10.24985] → [7.14905:15099]
∅:D[12.14696] → [7.14905:15099]
∅:D[8.51036] → [7.14905:15099]
∅:D[7.14905] → [7.14905:15099]
∅:D[7.15099] → [2.65100:65118]
∅:D[18.24917] → [6.40259:40341]
∅:D[25.21020] → [6.40259:40341]
∅:D[9.32554] → [6.40259:40341]
∅:D[15.5335] → [6.40259:40341]
∅:D[4.27442] → [6.40259:40341]
∅:D[2.65118] → [6.40259:40341]
∅:D[20.14348] → [6.40259:40341]
∅:D[10.25004] → [6.40259:40341]
∅:D[29.12601] → [6.40259:40341]
∅:D[21.42591] → [6.40259:40341]
∅:D[11.17882] → [6.40259:40341]
∅:D[39.9375] → [6.40259:40341]
∅:D[22.6897] → [6.40259:40341]
∅:D[31.17732] → [6.40259:40341]
∅:D[12.14715] → [6.40259:40341]
∅:D[23.9334] → [6.40259:40341]
∅:D[24.9744] → [6.40259:40341]
∅:D[7.15117] → [6.40259:40341]
∅:D[8.51055] → [6.40259:40341]
∅:D[6.40259] → [6.40259:40341]
∅:D[6.40341] → [7.15118:15193]
∅:D[14.12401] → [6.40729:40744]
∅:D[7.15193] → [6.40729:40744]
∅:D[6.40729] → [6.40729:40744]
∅:D[6.40956] → [6.40956:41080]
∅:D[6.41080] → [2.65119:65192]
∅:D[25.21094] → [6.41153:41189]
∅:D[4.27516] → [6.41153:41189]
∅:D[2.65192] → [6.41153:41189]
∅:D[8.51129] → [6.41153:41189]
∅:D[6.41153] → [6.41153:41189]
∅:D[6.41189] → [8.51130:51148]
∅:D[18.25108] → [6.41207:41481]
∅:D[9.32573] → [6.41207:41481]
∅:D[14.12420] → [6.41207:41481]
∅:D[4.27535] → [6.41207:41481]
∅:D[10.25023] → [6.41207:41481]
∅:D[21.42782] → [6.41207:41481]
∅:D[11.18073] → [6.41207:41481]
∅:D[12.14734] → [6.41207:41481]
∅:D[8.51148] → [6.41207:41481]
∅:D[6.41207] → [6.41207:41481]
∅:D[6.41481] → [2.65193:65212]
∅:D[18.25128] → [6.41499:41801]
∅:D[25.21114] → [6.41499:41801]
∅:D[9.32593] → [6.41499:41801]
∅:D[14.12439] → [6.41499:41801]
∅:D[15.5527] → [6.41499:41801]
∅:D[4.27554] → [6.41499:41801]
∅:D[2.65212] → [6.41499:41801]
∅:D[20.14540] → [6.41499:41801]
∅:D[10.25043] → [6.41499:41801]
∅:D[29.12793] → [6.41499:41801]
∅:D[21.42802] → [6.41499:41801]
∅:D[11.18092] → [6.41499:41801]
∅:D[39.9567] → [6.41499:41801]
∅:D[22.7088] → [6.41499:41801]
∅:D[31.17923] → [6.41499:41801]
∅:D[12.14753] → [6.41499:41801]
∅:D[23.9525] → [6.41499:41801]
∅:D[24.9935] → [6.41499:41801]
∅:D[8.51168] → [6.41499:41801]
∅:D[6.41499] → [6.41499:41801]
∅:D[6.41801] → [7.15194:15212]
∅:D[4.27668] → [12.14789:14867]
∅:D[12.14789] → [12.14789:14867]
∅:D[11.18206] → [6.42010:42024]
∅:D[12.14867] → [6.42010:42024]
∅:D[6.42010] → [6.42010:42024]
∅:D[6.42024] → [8.51169:51187]
∅:D[18.25147] → [6.42042:42124]
∅:D[9.32612] → [6.42042:42124]
∅:D[14.12590] → [6.42042:42124]
∅:D[4.27687] → [6.42042:42124]
∅:D[10.25062] → [6.42042:42124]
∅:D[21.42821] → [6.42042:42124]
∅:D[11.18225] → [6.42042:42124]
∅:D[12.14886] → [6.42042:42124]
∅:D[8.51187] → [6.42042:42124]
∅:D[6.42042] → [6.42042:42124]
∅:D[6.42124] → [8.51188:51406]
∅:D[8.51406] → [2.65213:65287]
∅:D[2.65287] → [8.51480:51623]
∅:D[8.51480] → [8.51480:51623]
∅:D[18.25583] → [6.42273:42276]
∅:D[9.33048] → [6.42273:42276]
∅:D[14.12740] → [6.42273:42276]
∅:D[15.5604] → [6.42273:42276]
∅:D[4.27837] → [6.42273:42276]
∅:D[20.14617] → [6.42273:42276]
∅:D[10.25498] → [6.42273:42276]
∅:D[29.12870] → [6.42273:42276]
∅:D[21.43257] → [6.42273:42276]
∅:D[11.18375] → [6.42273:42276]
∅:D[39.9644] → [6.42273:42276]
∅:D[22.7165] → [6.42273:42276]
∅:D[31.18000] → [6.42273:42276]
∅:D[12.15036] → [6.42273:42276]
∅:D[23.9602] → [6.42273:42276]
∅:D[24.10012] → [6.42273:42276]
∅:D[8.51623] → [6.42273:42276]
∅:D[6.42273] → [6.42273:42276]
```
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
[[package]]
name = "MacTypes-sys"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "aho-corasick"
version = "0.6.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "memchr 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "ansi_term"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "arc-swap"
version = "0.3.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "arrayvec"
version = "0.4.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "atty"
version = "0.2.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.49 (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.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "autocfg"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "backtrace"
version = "0.3.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-demangle 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "backtrace-sys"
version = "0.1.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cc 1.0.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "base64"
version = "0.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "bitflags"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "blake2"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "block-buffer"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "block-padding 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "block-padding"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "byte-tools"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "byteorder"
version = "1.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "bytes"
version = "0.4.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
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)",
]
[[package]]
name = "case"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "cc"
version = "1.0.30"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "cfg-if"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "chrono"
version = "0.4.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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)",
]
[[package]]
name = "clap"
version = "2.32.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
 "strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "textwrap 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
]
[[package]]
name = "cloudabi"
version = "0.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "core-foundation"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "core-foundation-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "core-foundation-sys"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "crossbeam-deque"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
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)",
]
[[package]]
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.6 (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.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "crypto-mac"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "subtle 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
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]]
name = "digest"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "encoding_rs"
version = "0.8.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "env_logger"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "termcolor 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "error-chain"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "backtrace 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "failure"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "backtrace 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "failure_derive"
version = "0.1.5"
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.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",
 "synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "fake-simd"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "fnv"
version = "1.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "foreign-types"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "foreign-types-shared 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "foreign-types-shared"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "fuchsia-cprng"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "fuchsia-zircon"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "fuchsia-zircon-sys"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "futf"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "mac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "futures"
version = "0.1.25"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "futures-cpupool"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "generic-array"
version = "0.12.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "typenum 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "h2"
version = "0.1.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "bytes 0.4.11 (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.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.16 (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)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "string 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "hmac"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "hostname"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "winutil 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "http"
version = "0.1.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.11 (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)",
]
[[package]]
name = "httparse"
version = "1.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "humantime"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "quick-error 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "hyper"
version = "0.12.25"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures-cpupool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "h2 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "http 0.1.16 (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.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.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.12 (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)",
]
[[package]]
name = "idna"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "matches 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "unicode-bidi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "unicode-normalization 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "indexmap"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "iovec"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "ipconfig"
version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winreg 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "itoa"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "jid"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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)",
]
[[package]]
name = "keccak"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "kernel32-sys"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "lazy_static"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "lazycell"
version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "libc"
version = "0.2.49"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "linked-hash-map"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "lock_api"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
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)",
]
[[package]]
name = "log"
version = "0.4.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "lru-cache"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "mac"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "markup5ever"
version = "0.7.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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.89 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.89 (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)",
 "tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "matches"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "memchr"
version = "2.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "memoffset"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "minidom"
version = "0.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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)",
]
[[package]]
name = "mio"
version = "0.6.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazycell 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "miow 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "net2 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "mio-uds"
version = "0.6.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "mio 0.6.16 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "miow"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "net2 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "ws2_32-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "native-tls"
version = "0.2.2"
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)",
 "libc 0.2.49 (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.19 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-probe 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.42 (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)",
]
[[package]]
name = "net2"
version = "0.2.33"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "new_debug_unreachable"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "nodrop"
version = "0.1.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "num-integer"
version = "0.1.39"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "num-traits 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "num-traits"
version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "num_cpus"
version = "1.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "opaque-debug"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "openssl"
version = "0.10.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "foreign-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "openssl-sys 0.9.42 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "openssl-probe"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "openssl-sys"
version = "0.9.42"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cc 1.0.30 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (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)",
]
[[package]]
name = "owning_ref"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "stable_deref_trait 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "parking_lot"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
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)",
]
[[package]]
name = "parking_lot_core"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.49 (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.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "pbkdf2"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "percent-encoding"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "phf"
version = "0.7.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "phf_codegen"
version = "0.7.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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)",
]
[[package]]
name = "phf_generator"
version = "0.7.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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)",
]
[[package]]
name = "phf_shared"
version = "0.7.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "siphasher 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "pkg-config"
version = "0.3.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "precomputed-hash"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "proc-macro2"
version = "0.4.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "quick-error"
version = "1.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "quick-xml"
version = "0.13.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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)",
]
[[package]]
name = "quote"
version = "0.3.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "quote"
version = "0.6.11"
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)",
]
[[package]]
name = "rand"
version = "0.5.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (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.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand"
version = "0.6.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (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.2 (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.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_chacha"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_core"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_core"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "rand_hc"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_isaac"
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]]
name = "rand_jitter"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.49 (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.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_os"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_pcg"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "autocfg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "rand_xorshift"
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]]
name = "rdrand"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "redox_syscall"
version = "0.1.51"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "redox_termios"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "regex"
version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "aho-corasick 0.6.10 (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.5 (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)",
]
[[package]]
name = "regex-syntax"
version = "0.6.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "ucd-util 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "remove_dir_all"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "resolv-conf"
version = "0.6.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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)",
]
[[package]]
name = "rustc-demangle"
version = "0.1.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
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]]
name = "ryu"
version = "0.2.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "sasl"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "hmac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "pbkdf2 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rand_os 0.1.2 (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)",
]
```
Deletion in Cargo.lock at line 1 [5.12201]
∅:D[6.42288] → [6.42288:42306]
∅:D[6.42288] → [6.42288:42306]
∅:D[6.42288] → [6.42288:42306]
∅:D[6.42288] → [6.42288:42306]
∅:D[6.42288] → [6.42288:42306]
∅:D[6.42288] → [6.42288:42306]
∅:D[6.42288] → [6.42288:42306]
∅:D[6.42288] → [6.42288:42306]
∅:D[6.42288] → [6.42288:42306]
∅:D[6.42288] → [6.42288:42306]
∅:D[6.42288] → [6.42288:42306]
∅:D[6.42288] → [6.42288:42306]
∅:D[6.42288] → [6.42288:42306]
∅:D[6.42288] → [6.42288:42306]
∅:D[6.42288] → [6.42288:42306]
∅:D[6.42288] → [6.42288:42306]
∅:D[6.42288] → [6.42288:42306]
∅:D[6.42288] → [6.42288:42306]
∅:D[6.42306] → [8.51624:51643]
∅:D[25.21209] → [6.42325:42407]
∅:D[27.15920] → [6.42325:42407]
∅:D[4.27857] → [6.42325:42407]
∅:D[26.20040] → [6.42325:42407]
∅:D[34.11816] → [6.42325:42407]
∅:D[36.7068] → [6.42325:42407]
∅:D[8.51643] → [6.42325:42407]
∅:D[6.42325] → [6.42325:42407]
∅:D[6.42407] → [8.51644:51722]
∅:D[8.51722] → [2.65288:65361]
∅:D[25.21361] → [6.42558:42717]
∅:D[4.28009] → [6.42558:42717]
∅:D[2.65361] → [6.42558:42717]
∅:D[8.51795] → [6.42558:42717]
∅:D[6.42558] → [6.42558:42717]
∅:D[6.42717] → [8.51796:51814]
∅:D[18.25602] → [6.42735:42985]
∅:D[9.33067] → [6.42735:42985]
∅:D[14.12838] → [6.42735:42985]
∅:D[4.28028] → [6.42735:42985]
∅:D[10.25517] → [6.42735:42985]
∅:D[21.43276] → [6.42735:42985]
∅:D[11.18394] → [6.42735:42985]
∅:D[12.15055] → [6.42735:42985]
∅:D[8.51814] → [6.42735:42985]
∅:D[6.42735] → [6.42735:42985]
∅:D[6.42985] → [2.65362:65434]
∅:D[2.65434] → [8.51887:51976]
∅:D[8.51887] → [8.51887:51976]
∅:D[18.25764] → [6.43146:43193]
∅:D[9.33229] → [6.43146:43193]
∅:D[14.13000] → [6.43146:43193]
∅:D[15.5766] → [6.43146:43193]
∅:D[4.28190] → [6.43146:43193]
∅:D[20.14779] → [6.43146:43193]
∅:D[10.25679] → [6.43146:43193]
∅:D[29.13032] → [6.43146:43193]
∅:D[21.43438] → [6.43146:43193]
∅:D[11.18556] → [6.43146:43193]
∅:D[31.18162] → [6.43146:43193]
∅:D[12.15217] → [6.43146:43193]
∅:D[23.9764] → [6.43146:43193]
∅:D[24.10174] → [6.43146:43193]
∅:D[8.51976] → [6.43146:43193]
∅:D[6.43146] → [6.43146:43193]
∅:D[6.43193] → [8.51977:51995]
∅:D[18.25783] → [6.43211:43293]
∅:D[9.33248] → [6.43211:43293]
∅:D[14.13019] → [6.43211:43293]
∅:D[15.5785] → [6.43211:43293]
∅:D[4.28209] → [6.43211:43293]
∅:D[20.14798] → [6.43211:43293]
∅:D[10.25698] → [6.43211:43293]
∅:D[29.13051] → [6.43211:43293]
∅:D[21.43457] → [6.43211:43293]
∅:D[11.18575] → [6.43211:43293]
∅:D[31.18181] → [6.43211:43293]
∅:D[12.15236] → [6.43211:43293]
∅:D[23.9783] → [6.43211:43293]
∅:D[24.10193] → [6.43211:43293]
∅:D[8.51995] → [6.43211:43293]
∅:D[6.43211] → [6.43211:43293]
∅:D[6.43293] → [8.51996:52075]
∅:D[18.25863] → [6.43293:43379]
∅:D[9.33328] → [6.43293:43379]
∅:D[15.5865] → [6.43293:43379]
∅:D[20.14878] → [6.43293:43379]
∅:D[10.25778] → [6.43293:43379]
∅:D[29.13131] → [6.43293:43379]
∅:D[21.43537] → [6.43293:43379]
∅:D[8.52075] → [6.43293:43379]
∅:D[6.43293] → [6.43293:43379]
∅:D[6.43379] → [2.65435:65507]
∅:D[18.25936] → [6.43451:43796]
∅:D[25.21507] → [6.43451:43796]
∅:D[9.33401] → [6.43451:43796]
∅:D[27.16145] → [6.43451:43796]
∅:D[14.13092] → [6.43451:43796]
∅:D[15.5938] → [6.43451:43796]
∅:D[4.28282] → [6.43451:43796]
∅:D[2.65507] → [6.43451:43796]
∅:D[33.7136] → [6.43451:43796]
∅:D[35.6764] → [6.43451:43796]
∅:D[26.20265] → [6.43451:43796]
∅:D[20.14951] → [6.43451:43796]
∅:D[10.25851] → [6.43451:43796]
∅:D[29.13204] → [6.43451:43796]
∅:D[21.43610] → [6.43451:43796]
∅:D[11.18648] → [6.43451:43796]
∅:D[39.9790] → [6.43451:43796]
∅:D[22.7311] → [6.43451:43796]
∅:D[31.18254] → [6.43451:43796]
∅:D[34.12041] → [6.43451:43796]
∅:D[12.15309] → [6.43451:43796]
∅:D[23.9856] → [6.43451:43796]
∅:D[36.7293] → [6.43451:43796]
∅:D[24.10266] → [6.43451:43796]
∅:D[7.15437] → [6.43451:43796]
∅:D[8.52148] → [6.43451:43796]
∅:D[6.43451] → [6.43451:43796]
```
name = "schannel"
version = "0.1.15"
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)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "scopeguard"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "security-framework"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "security-framework-sys 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "security-framework-sys"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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.49 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
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]]
```
Deletion in Cargo.lock at line 3 [5.12201]
∅:D[6.43815] → [6.43815:43832]
∅:D[6.43832] → [2.65508:65657]
∅:D[2.65657] → [8.52298:52372]
∅:D[8.52298] → [8.52298:52372]
∅:D[8.52372] → [2.65658:65732]
∅:D[37.1219] → [7.15663:15733]
∅:D[25.21732] → [7.15663:15733]
∅:D[9.33550] → [7.15663:15733]
∅:D[27.16298] → [7.15663:15733]
∅:D[4.28580] → [7.15663:15733]
∅:D[2.65732] → [7.15663:15733]
∅:D[26.20340] → [7.15663:15733]
∅:D[10.26000] → [7.15663:15733]
∅:D[34.12116] → [7.15663:15733]
∅:D[12.15458] → [7.15663:15733]
∅:D[38.5570] → [7.15663:15733]
∅:D[36.7446] → [7.15663:15733]
∅:D[8.52446] → [7.15663:15733]
∅:D[7.15663] → [7.15663:15733]
∅:D[7.15733] → [8.52447:52522]
∅:D[8.52522] → [2.65733:65959]
∅:D[25.21959] → [7.15881:16040]
∅:D[9.33852] → [7.15881:16040]
∅:D[27.16525] → [7.15881:16040]
∅:D[4.28881] → [7.15881:16040]
∅:D[2.65959] → [7.15881:16040]
∅:D[35.6916] → [7.15881:16040]
∅:D[26.20567] → [7.15881:16040]
∅:D[10.26302] → [7.15881:16040]
∅:D[34.12343] → [7.15881:16040]
∅:D[12.15759] → [7.15881:16040]
∅:D[36.7673] → [7.15881:16040]
∅:D[8.52748] → [7.15881:16040]
∅:D[7.15881] → [7.15881:16040]
∅:D[7.16040] → [8.52749:52826]
∅:D[8.52826] → [2.65960:66187]
∅:D[18.26621] → [6.44887:44917]
∅:D[25.22111] → [6.44887:44917]
∅:D[9.34086] → [6.44887:44917]
∅:D[27.16679] → [6.44887:44917]
∅:D[14.13620] → [6.44887:44917]
∅:D[4.29186] → [6.44887:44917]
∅:D[2.66187] → [6.44887:44917]
∅:D[35.7069] → [6.44887:44917]
∅:D[10.26536] → [6.44887:44917]
∅:D[21.44295] → [6.44887:44917]
∅:D[11.19257] → [6.44887:44917]
∅:D[12.15993] → [6.44887:44917]
∅:D[7.16268] → [6.44887:44917]
∅:D[8.52977] → [6.44887:44917]
∅:D[6.44887] → [6.44887:44917]
∅:D[6.44917] → [2.66188:66207]
∅:D[37.1393] → [6.44936:45036]
∅:D[18.26641] → [6.44936:45036]
∅:D[25.22131] → [6.44936:45036]
∅:D[9.34106] → [6.44936:45036]
∅:D[27.16699] → [6.44936:45036]
∅:D[14.13640] → [6.44936:45036]
∅:D[15.6265] → [6.44936:45036]
∅:D[4.29206] → [6.44936:45036]
∅:D[2.66207] → [6.44936:45036]
∅:D[26.20587] → [6.44936:45036]
∅:D[20.15424] → [6.44936:45036]
∅:D[10.26556] → [6.44936:45036]
∅:D[29.13605] → [6.44936:45036]
∅:D[21.44315] → [6.44936:45036]
∅:D[11.19277] → [6.44936:45036]
∅:D[39.10039] → [6.44936:45036]
∅:D[22.7560] → [6.44936:45036]
∅:D[31.18657] → [6.44936:45036]
∅:D[34.12363] → [6.44936:45036]
∅:D[12.16013] → [6.44936:45036]
∅:D[23.10257] → [6.44936:45036]
∅:D[38.5744] → [6.44936:45036]
∅:D[36.7693] → [6.44936:45036]
∅:D[24.10593] → [6.44936:45036]
∅:D[8.52997] → [6.44936:45036]
∅:D[6.44936] → [6.44936:45036]
∅:D[6.45036] → [2.66208:66227]
∅:D[37.1413] → [6.45055:45137]
∅:D[18.26661] → [6.45055:45137]
∅:D[25.22151] → [6.45055:45137]
∅:D[9.34126] → [6.45055:45137]
∅:D[27.16719] → [6.45055:45137]
∅:D[14.13660] → [6.45055:45137]
∅:D[15.6285] → [6.45055:45137]
∅:D[4.29226] → [6.45055:45137]
∅:D[2.66227] → [6.45055:45137]
∅:D[26.20607] → [6.45055:45137]
∅:D[20.15444] → [6.45055:45137]
∅:D[10.26576] → [6.45055:45137]
∅:D[29.13625] → [6.45055:45137]
∅:D[21.44335] → [6.45055:45137]
∅:D[11.19297] → [6.45055:45137]
∅:D[39.10059] → [6.45055:45137]
∅:D[22.7580] → [6.45055:45137]
∅:D[31.18677] → [6.45055:45137]
∅:D[34.12383] → [6.45055:45137]
∅:D[12.16033] → [6.45055:45137]
∅:D[23.10277] → [6.45055:45137]
∅:D[38.5764] → [6.45055:45137]
∅:D[36.7713] → [6.45055:45137]
∅:D[24.10613] → [6.45055:45137]
∅:D[8.53017] → [6.45055:45137]
∅:D[6.45055] → [6.45055:45137]
∅:D[6.45137] → [8.53018:53097]
∅:D[8.53097] → [2.66228:66373]
∅:D[18.26886] → [6.45361:45396]
∅:D[25.22297] → [6.45361:45396]
∅:D[9.34351] → [6.45361:45396]
∅:D[27.16792] → [6.45361:45396]
∅:D[14.13884] → [6.45361:45396]
∅:D[15.6358] → [6.45361:45396]
∅:D[4.29451] → [6.45361:45396]
∅:D[2.66373] → [6.45361:45396]
∅:D[33.7287] → [6.45361:45396]
∅:D[35.7142] → [6.45361:45396]
∅:D[26.20680] → [6.45361:45396]
∅:D[20.15517] → [6.45361:45396]
∅:D[10.26801] → [6.45361:45396]
∅:D[29.13698] → [6.45361:45396]
∅:D[21.44560] → [6.45361:45396]
∅:D[11.19522] → [6.45361:45396]
∅:D[39.10132] → [6.45361:45396]
∅:D[22.7653] → [6.45361:45396]
∅:D[31.18750] → [6.45361:45396]
∅:D[34.12456] → [6.45361:45396]
∅:D[12.16258] → [6.45361:45396]
∅:D[23.10350] → [6.45361:45396]
∅:D[36.7786] → [6.45361:45396]
∅:D[24.10686] → [6.45361:45396]
∅:D[7.16493] → [6.45361:45396]
∅:D[8.53242] → [6.45361:45396]
∅:D[6.45361] → [6.45361:45396]
∅:D[6.45396] → [8.53243:53262]
∅:D[18.26906] → [6.45415:45568]
∅:D[25.22317] → [6.45415:45568]
∅:D[9.34371] → [6.45415:45568]
∅:D[27.16812] → [6.45415:45568]
∅:D[13.8652] → [6.45415:45568]
∅:D[14.13904] → [6.45415:45568]
∅:D[4.29471] → [6.45415:45568]
∅:D[26.20700] → [6.45415:45568]
∅:D[10.26821] → [6.45415:45568]
∅:D[21.44580] → [6.45415:45568]
∅:D[11.19542] → [6.45415:45568]
∅:D[31.18770] → [6.45415:45568]
∅:D[34.12476] → [6.45415:45568]
∅:D[12.16278] → [6.45415:45568]
∅:D[36.7806] → [6.45415:45568]
∅:D[7.16513] → [6.45415:45568]
∅:D[8.53262] → [6.45415:45568]
∅:D[6.45415] → [6.45415:45568]
∅:D[6.45568] → [7.16514:16584]
∅:D[7.16584] → [2.66374:66447]
∅:D[37.1487] → [6.45711:45713]
∅:D[18.26980] → [6.45711:45713]
∅:D[25.22391] → [6.45711:45713]
∅:D[9.34445] → [6.45711:45713]
∅:D[27.16886] → [6.45711:45713]
∅:D[14.14048] → [6.45711:45713]
∅:D[15.6432] → [6.45711:45713]
∅:D[4.29545] → [6.45711:45713]
∅:D[2.66447] → [6.45711:45713]
∅:D[26.20774] → [6.45711:45713]
∅:D[20.15591] → [6.45711:45713]
∅:D[10.26895] → [6.45711:45713]
∅:D[29.13772] → [6.45711:45713]
∅:D[21.44654] → [6.45711:45713]
∅:D[11.19616] → [6.45711:45713]
∅:D[39.10206] → [6.45711:45713]
∅:D[22.7727] → [6.45711:45713]
∅:D[31.18844] → [6.45711:45713]
∅:D[34.12550] → [6.45711:45713]
∅:D[12.16352] → [6.45711:45713]
∅:D[23.10424] → [6.45711:45713]
∅:D[38.5838] → [6.45711:45713]
∅:D[36.7880] → [6.45711:45713]
∅:D[24.10760] → [6.45711:45713]
∅:D[8.53336] → [6.45711:45713]
∅:D[6.45711] → [6.45711:45713]
```
dependencies = [
 "clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "hyper 0.12.25 (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.89 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_derive 1.0.89 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.16 (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.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
 "try_from 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "xmpp-parsers 0.12.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "serde"
version = "1.0.89"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "serde_derive"
version = "1.0.89"
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.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "serde_json"
version = "1.0.39"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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.89 (registry+https://github.com/rust-lang/crates.io-index)",
]
```
Deletion in Cargo.lock at line 4 [5.12201]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45714] → [6.45714:45741]
∅:D[6.45741] → [8.53337:53355]
∅:D[18.26999] → [6.45759:45841]
∅:D[9.34464] → [6.45759:45841]
∅:D[14.14067] → [6.45759:45841]
∅:D[4.29564] → [6.45759:45841]
∅:D[10.26914] → [6.45759:45841]
∅:D[21.44673] → [6.45759:45841]
∅:D[11.19635] → [6.45759:45841]
∅:D[12.16371] → [6.45759:45841]
∅:D[8.53355] → [6.45759:45841]
∅:D[6.45759] → [6.45759:45841]
∅:D[6.45841] → [8.53356:53508]
∅:D[18.27152] → [6.46070:46146]
∅:D[9.34617] → [6.46070:46146]
∅:D[14.14297] → [6.46070:46146]
∅:D[4.29794] → [6.46070:46146]
∅:D[10.27067] → [6.46070:46146]
∅:D[21.44826] → [6.46070:46146]
∅:D[11.19865] → [6.46070:46146]
∅:D[12.16601] → [6.46070:46146]
∅:D[8.53508] → [6.46070:46146]
∅:D[6.46070] → [6.46070:46146]
∅:D[6.46146] → [8.53509:53588]
∅:D[18.27232] → [6.46146:46175]
∅:D[9.34697] → [6.46146:46175]
∅:D[10.27147] → [6.46146:46175]
∅:D[21.44906] → [6.46146:46175]
∅:D[8.53588] → [6.46146:46175]
∅:D[6.46146] → [6.46146:46175]
∅:D[6.46175] → [8.53589:53607]
∅:D[18.27251] → [6.46193:46275]
∅:D[9.34716] → [6.46193:46275]
∅:D[14.14316] → [6.46193:46275]
∅:D[4.29813] → [6.46193:46275]
∅:D[10.27166] → [6.46193:46275]
∅:D[21.44925] → [6.46193:46275]
∅:D[11.19884] → [6.46193:46275]
∅:D[12.16620] → [6.46193:46275]
∅:D[8.53607] → [6.46193:46275]
∅:D[6.46193] → [6.46193:46275]
∅:D[6.46275] → [8.53608:53760]
∅:D[18.27404] → [6.46504:46580]
∅:D[9.34869] → [6.46504:46580]
∅:D[14.14546] → [6.46504:46580]
∅:D[4.30043] → [6.46504:46580]
∅:D[10.27319] → [6.46504:46580]
∅:D[21.45078] → [6.46504:46580]
∅:D[11.20114] → [6.46504:46580]
∅:D[12.16850] → [6.46504:46580]
∅:D[8.53760] → [6.46504:46580]
∅:D[6.46504] → [6.46504:46580]
∅:D[6.46580] → [8.53761:53840]
∅:D[18.27484] → [6.46580:46609]
∅:D[9.34949] → [6.46580:46609]
∅:D[10.27399] → [6.46580:46609]
∅:D[21.45158] → [6.46580:46609]
∅:D[8.53840] → [6.46580:46609]
∅:D[6.46580] → [6.46580:46609]
∅:D[6.46609] → [8.53841:53859]
∅:D[18.27503] → [6.46627:46709]
∅:D[9.34968] → [6.46627:46709]
∅:D[14.14565] → [6.46627:46709]
∅:D[4.30062] → [6.46627:46709]
∅:D[10.27418] → [6.46627:46709]
∅:D[21.45177] → [6.46627:46709]
∅:D[11.20133] → [6.46627:46709]
∅:D[12.16869] → [6.46627:46709]
∅:D[8.53859] → [6.46627:46709]
∅:D[6.46627] → [6.46627:46709]
∅:D[6.46709] → [8.53860:54089]
∅:D[18.27733] → [6.46938:47011]
∅:D[9.35198] → [6.46938:47011]
∅:D[14.14795] → [6.46938:47011]
∅:D[4.30292] → [6.46938:47011]
∅:D[10.27648] → [6.46938:47011]
∅:D[21.45407] → [6.46938:47011]
∅:D[11.20363] → [6.46938:47011]
∅:D[12.17099] → [6.46938:47011]
∅:D[8.54089] → [6.46938:47011]
∅:D[6.46938] → [6.46938:47011]
∅:D[6.47011] → [8.54090:54169]
∅:D[18.27813] → [6.47011:47047]
∅:D[9.35278] → [6.47011:47047]
∅:D[10.27728] → [6.47011:47047]
∅:D[21.45487] → [6.47011:47047]
∅:D[8.54169] → [6.47011:47047]
∅:D[6.47011] → [6.47011:47047]
∅:D[6.47047] → [8.54170:54188]
∅:D[18.27832] → [6.47065:47147]
∅:D[25.22650] → [6.47065:47147]
∅:D[9.35297] → [6.47065:47147]
∅:D[27.17145] → [6.47065:47147]
∅:D[14.14814] → [6.47065:47147]
∅:D[15.6451] → [6.47065:47147]
∅:D[4.30311] → [6.47065:47147]
∅:D[26.21033] → [6.47065:47147]
∅:D[20.15610] → [6.47065:47147]
∅:D[10.27747] → [6.47065:47147]
∅:D[29.13791] → [6.47065:47147]
∅:D[21.45506] → [6.47065:47147]
∅:D[11.20382] → [6.47065:47147]
∅:D[31.18863] → [6.47065:47147]
∅:D[34.12809] → [6.47065:47147]
∅:D[12.17118] → [6.47065:47147]
∅:D[23.10443] → [6.47065:47147]
∅:D[36.8139] → [6.47065:47147]
∅:D[24.10779] → [6.47065:47147]
∅:D[7.16603] → [6.47065:47147]
∅:D[8.54188] → [6.47065:47147]
∅:D[6.47065] → [6.47065:47147]
∅:D[6.47147] → [2.66448:66595]
∅:D[18.27980] → [6.47294:47438]
∅:D[25.22799] → [6.47294:47438]
∅:D[9.35445] → [6.47294:47438]
∅:D[27.17218] → [6.47294:47438]
∅:D[14.14962] → [6.47294:47438]
∅:D[15.6599] → [6.47294:47438]
∅:D[4.30459] → [6.47294:47438]
∅:D[2.66595] → [6.47294:47438]
∅:D[33.7360] → [6.47294:47438]
∅:D[35.7215] → [6.47294:47438]
∅:D[26.21106] → [6.47294:47438]
∅:D[20.15758] → [6.47294:47438]
∅:D[10.27895] → [6.47294:47438]
∅:D[29.13939] → [6.47294:47438]
∅:D[21.45654] → [6.47294:47438]
∅:D[11.20530] → [6.47294:47438]
∅:D[39.10279] → [6.47294:47438]
∅:D[22.7800] → [6.47294:47438]
∅:D[31.19011] → [6.47294:47438]
∅:D[34.12882] → [6.47294:47438]
∅:D[12.17266] → [6.47294:47438]
∅:D[23.10591] → [6.47294:47438]
∅:D[36.8212] → [6.47294:47438]
∅:D[24.10927] → [6.47294:47438]
∅:D[7.16751] → [6.47294:47438]
∅:D[8.54337] → [6.47294:47438]
∅:D[6.47294] → [6.47294:47438]
∅:D[6.47438] → [8.54338:54356]
∅:D[18.27999] → [6.47456:47552]
∅:D[9.35464] → [6.47456:47552]
∅:D[14.14981] → [6.47456:47552]
∅:D[4.30478] → [6.47456:47552]
∅:D[10.27914] → [6.47456:47552]
∅:D[21.45673] → [6.47456:47552]
∅:D[11.20549] → [6.47456:47552]
∅:D[12.17285] → [6.47456:47552]
∅:D[8.54356] → [6.47456:47552]
∅:D[6.47456] → [6.47456:47552]
∅:D[6.47552] → [8.54357:54375]
∅:D[37.1746] → [6.47570:47635]
∅:D[18.28018] → [6.47570:47635]
∅:D[25.22818] → [6.47570:47635]
∅:D[9.35483] → [6.47570:47635]
∅:D[27.17237] → [6.47570:47635]
∅:D[14.15000] → [6.47570:47635]
∅:D[15.6618] → [6.47570:47635]
∅:D[4.30497] → [6.47570:47635]
∅:D[26.21125] → [6.47570:47635]
∅:D[20.15777] → [6.47570:47635]
∅:D[10.27933] → [6.47570:47635]
∅:D[29.13958] → [6.47570:47635]
∅:D[21.45692] → [6.47570:47635]
∅:D[11.20568] → [6.47570:47635]
∅:D[39.10298] → [6.47570:47635]
∅:D[22.7819] → [6.47570:47635]
∅:D[31.19030] → [6.47570:47635]
∅:D[34.12901] → [6.47570:47635]
∅:D[12.17304] → [6.47570:47635]
∅:D[23.10610] → [6.47570:47635]
∅:D[38.6097] → [6.47570:47635]
∅:D[36.8231] → [6.47570:47635]
∅:D[24.10946] → [6.47570:47635]
∅:D[7.16770] → [6.47570:47635]
∅:D[8.54375] → [6.47570:47635]
∅:D[6.47570] → [6.47570:47635]
∅:D[27.17335] → [6.47732:47862]
∅:D[4.30595] → [6.47732:47862]
∅:D[34.12999] → [6.47732:47862]
∅:D[38.6195] → [6.47732:47862]
∅:D[6.47732] → [6.47732:47862]
∅:D[6.47862] → [2.66596:66895]
∅:D[25.23118] → [6.48161:48316]
∅:D[4.30895] → [6.48161:48316]
∅:D[2.66895] → [6.48161:48316]
∅:D[8.54675] → [6.48161:48316]
∅:D[6.48161] → [6.48161:48316]
∅:D[6.48316] → [8.54676:54694]
∅:D[18.28191] → [6.48334:48534]
∅:D[9.35656] → [6.48334:48534]
∅:D[14.15173] → [6.48334:48534]
∅:D[4.30914] → [6.48334:48534]
∅:D[10.28106] → [6.48334:48534]
∅:D[21.45865] → [6.48334:48534]
∅:D[11.20741] → [6.48334:48534]
∅:D[12.17477] → [6.48334:48534]
∅:D[7.16943] → [6.48334:48534]
∅:D[8.54694] → [6.48334:48534]
∅:D[6.48334] → [6.48334:48534]
∅:D[6.48534] → [8.54695:54939]
∅:D[18.28270] → [6.48778:48861]
∅:D[9.35735] → [6.48778:48861]
∅:D[14.15331] → [6.48778:48861]
∅:D[4.31159] → [6.48778:48861]
∅:D[10.28185] → [6.48778:48861]
∅:D[21.45944] → [6.48778:48861]
∅:D[11.20820] → [6.48778:48861]
∅:D[12.17556] → [6.48778:48861]
∅:D[8.54939] → [6.48778:48861]
∅:D[6.48778] → [6.48778:48861]
∅:D[6.48861] → [2.66896:66969]
∅:D[37.1909] → [6.48934:49252]
∅:D[18.28344] → [6.48934:49252]
∅:D[25.23359] → [6.48934:49252]
∅:D[9.35809] → [6.48934:49252]
∅:D[27.17722] → [6.48934:49252]
∅:D[14.15405] → [6.48934:49252]
∅:D[15.6846] → [6.48934:49252]
∅:D[4.31233] → [6.48934:49252]
∅:D[2.66969] → [6.48934:49252]
∅:D[26.21439] → [6.48934:49252]
∅:D[20.16005] → [6.48934:49252]
∅:D[10.28259] → [6.48934:49252]
∅:D[29.14186] → [6.48934:49252]
∅:D[21.46018] → [6.48934:49252]
∅:D[11.20894] → [6.48934:49252]
∅:D[39.10526] → [6.48934:49252]
∅:D[22.8047] → [6.48934:49252]
∅:D[31.19258] → [6.48934:49252]
∅:D[34.13313] → [6.48934:49252]
∅:D[12.17630] → [6.48934:49252]
∅:D[23.10838] → [6.48934:49252]
∅:D[38.6358] → [6.48934:49252]
∅:D[36.8618] → [6.48934:49252]
∅:D[24.11174] → [6.48934:49252]
∅:D[8.55013] → [6.48934:49252]
∅:D[6.48934] → [6.48934:49252]
∅:D[6.49252] → [8.55014:55252]
∅:D[8.55252] → [2.66970:67043]
∅:D[18.28656] → [6.49563:49805]
∅:D[25.23433] → [6.49563:49805]
∅:D[9.36121] → [6.49563:49805]
∅:D[14.15716] → [6.49563:49805]
∅:D[4.31545] → [6.49563:49805]
∅:D[2.67043] → [6.49563:49805]
∅:D[10.28571] → [6.49563:49805]
∅:D[21.46330] → [6.49563:49805]
∅:D[11.21206] → [6.49563:49805]
∅:D[12.17942] → [6.49563:49805]
∅:D[7.17175] → [6.49563:49805]
∅:D[8.55325] → [6.49563:49805]
∅:D[6.49563] → [6.49563:49805]
∅:D[6.49805] → [2.67044:67062]
∅:D[2.67062] → [8.55344:55456]
∅:D[8.55344] → [8.55344:55456]
∅:D[9.36234] → [6.49823:49901]
∅:D[4.31564] → [6.49823:49901]
∅:D[8.55456] → [6.49823:49901]
∅:D[6.49823] → [6.49823:49901]
∅:D[18.28769] → [6.49901:50268]
∅:D[10.28684] → [6.49901:50268]
∅:D[21.46443] → [6.49901:50268]
∅:D[6.49901] → [6.49901:50268]
∅:D[6.50268] → [2.67063:67083]
∅:D[18.28790] → [6.50288:50370]
∅:D[25.23473] → [6.50288:50370]
∅:D[9.36255] → [6.50288:50370]
∅:D[27.17743] → [6.50288:50370]
∅:D[14.15737] → [6.50288:50370]
∅:D[15.6867] → [6.50288:50370]
∅:D[4.31585] → [6.50288:50370]
∅:D[2.67083] → [6.50288:50370]
∅:D[33.7527] → [6.50288:50370]
∅:D[35.7382] → [6.50288:50370]
∅:D[26.21460] → [6.50288:50370]
∅:D[20.16026] → [6.50288:50370]
∅:D[10.28705] → [6.50288:50370]
∅:D[29.14207] → [6.50288:50370]
∅:D[21.46464] → [6.50288:50370]
∅:D[11.21227] → [6.50288:50370]
∅:D[39.10547] → [6.50288:50370]
∅:D[22.8068] → [6.50288:50370]
∅:D[31.19279] → [6.50288:50370]
∅:D[34.13334] → [6.50288:50370]
∅:D[12.17963] → [6.50288:50370]
∅:D[23.10859] → [6.50288:50370]
∅:D[36.8639] → [6.50288:50370]
∅:D[24.11195] → [6.50288:50370]
∅:D[7.17196] → [6.50288:50370]
∅:D[8.55477] → [6.50288:50370]
∅:D[6.50288] → [6.50288:50370]
∅:D[6.50370] → [8.55478:55557]
∅:D[8.55557] → [2.67084:67157]
∅:D[18.28943] → [6.50522:50846]
∅:D[25.23547] → [6.50522:50846]
∅:D[9.36408] → [6.50522:50846]
∅:D[14.15889] → [6.50522:50846]
∅:D[4.31738] → [6.50522:50846]
∅:D[2.67157] → [6.50522:50846]
∅:D[10.28858] → [6.50522:50846]
∅:D[21.46617] → [6.50522:50846]
∅:D[11.21380] → [6.50522:50846]
∅:D[12.18116] → [6.50522:50846]
∅:D[7.17349] → [6.50522:50846]
∅:D[8.55630] → [6.50522:50846]
∅:D[6.50522] → [6.50522:50846]
∅:D[6.50846] → [7.17350:17369]
∅:D[14.15909] → [6.50865:50947]
∅:D[7.17369] → [6.50865:50947]
∅:D[6.50865] → [6.50865:50947]
∅:D[6.50947] → [8.55631:55710]
∅:D[8.55710] → [2.67158:67303]
∅:D[18.29168] → [6.51171:51282]
∅:D[25.23693] → [6.51171:51282]
∅:D[9.36633] → [6.51171:51282]
∅:D[27.17816] → [6.51171:51282]
∅:D[14.16133] → [6.51171:51282]
∅:D[15.6940] → [6.51171:51282]
∅:D[4.31963] → [6.51171:51282]
∅:D[2.67303] → [6.51171:51282]
∅:D[33.7600] → [6.51171:51282]
∅:D[35.7455] → [6.51171:51282]
∅:D[26.21533] → [6.51171:51282]
∅:D[20.16099] → [6.51171:51282]
∅:D[10.29083] → [6.51171:51282]
∅:D[29.14280] → [6.51171:51282]
∅:D[21.46842] → [6.51171:51282]
∅:D[11.21605] → [6.51171:51282]
∅:D[39.10620] → [6.51171:51282]
∅:D[22.8141] → [6.51171:51282]
∅:D[31.19352] → [6.51171:51282]
∅:D[34.13407] → [6.51171:51282]
∅:D[12.18341] → [6.51171:51282]
∅:D[23.10932] → [6.51171:51282]
∅:D[36.8712] → [6.51171:51282]
∅:D[24.11268] → [6.51171:51282]
∅:D[7.17594] → [6.51171:51282]
∅:D[8.55855] → [6.51171:51282]
∅:D[6.51171] → [6.51171:51282]
∅:D[6.51282] → [8.55856:55874]
∅:D[37.1928] → [6.51300:51382]
∅:D[25.23712] → [6.51300:51382]
∅:D[9.36652] → [6.51300:51382]
∅:D[27.17835] → [6.51300:51382]
∅:D[14.16152] → [6.51300:51382]
∅:D[4.31982] → [6.51300:51382]
∅:D[26.21552] → [6.51300:51382]
∅:D[34.13426] → [6.51300:51382]
∅:D[38.6377] → [6.51300:51382]
∅:D[36.8731] → [6.51300:51382]
∅:D[7.17613] → [6.51300:51382]
∅:D[8.55874] → [6.51300:51382]
∅:D[6.51300] → [6.51300:51382]
∅:D[6.51382] → [2.67304:67449]
∅:D[2.67449] → [8.56020:56091]
∅:D[8.56020] → [8.56020:56091]
∅:D[8.56091] → [2.67450:67531]
∅:D[18.29393] → [6.51679:51760]
∅:D[25.23940] → [6.51679:51760]
∅:D[9.36877] → [6.51679:51760]
∅:D[14.16377] → [6.51679:51760]
∅:D[15.7095] → [6.51679:51760]
∅:D[4.32280] → [6.51679:51760]
∅:D[2.67531] → [6.51679:51760]
∅:D[20.16254] → [6.51679:51760]
∅:D[10.29308] → [6.51679:51760]
∅:D[29.14435] → [6.51679:51760]
∅:D[21.47067] → [6.51679:51760]
∅:D[11.21830] → [6.51679:51760]
∅:D[39.10775] → [6.51679:51760]
∅:D[22.8296] → [6.51679:51760]
∅:D[31.19507] → [6.51679:51760]
∅:D[12.18566] → [6.51679:51760]
∅:D[23.11087] → [6.51679:51760]
∅:D[24.11423] → [6.51679:51760]
∅:D[7.17838] → [6.51679:51760]
∅:D[8.56172] → [6.51679:51760]
∅:D[6.51679] → [6.51679:51760]
∅:D[6.51760] → [2.67532:67605]
∅:D[25.24014] → [6.51833:51865]
∅:D[4.32354] → [6.51833:51865]
∅:D[2.67605] → [6.51833:51865]
∅:D[8.56246] → [6.51833:51865]
∅:D[6.51833] → [6.51833:51865]
∅:D[6.51865] → [8.56247:56265]
∅:D[18.29412] → [6.51883:52106]
∅:D[9.36896] → [6.51883:52106]
∅:D[14.16396] → [6.51883:52106]
∅:D[15.7114] → [6.51883:52106]
∅:D[4.32373] → [6.51883:52106]
∅:D[20.16273] → [6.51883:52106]
∅:D[10.29327] → [6.51883:52106]
∅:D[29.14454] → [6.51883:52106]
∅:D[21.47086] → [6.51883:52106]
∅:D[11.21849] → [6.51883:52106]
∅:D[39.10794] → [6.51883:52106]
∅:D[22.8315] → [6.51883:52106]
∅:D[31.19526] → [6.51883:52106]
∅:D[12.18585] → [6.51883:52106]
∅:D[23.11106] → [6.51883:52106]
∅:D[24.11442] → [6.51883:52106]
∅:D[8.56265] → [6.51883:52106]
∅:D[6.51883] → [6.51883:52106]
∅:D[6.52106] → [8.56266:56338]
∅:D[9.36969] → [7.17839:18048]
∅:D[4.32446] → [7.17839:18048]
∅:D[10.29400] → [7.17839:18048]
∅:D[12.18658] → [7.17839:18048]
∅:D[8.56338] → [7.17839:18048]
∅:D[14.16469] → [7.17839:18048]
∅:D[14.16469] → [6.52387:52519]
∅:D[7.18048] → [6.52387:52519]
∅:D[6.52387] → [6.52387:52519]
∅:D[6.52519] → [2.67606:67759]
∅:D[18.29639] → [6.52672:52785]
∅:D[25.24168] → [6.52672:52785]
∅:D[9.37123] → [6.52672:52785]
∅:D[14.16623] → [6.52672:52785]
∅:D[15.7268] → [6.52672:52785]
∅:D[4.32600] → [6.52672:52785]
∅:D[2.67759] → [6.52672:52785]
∅:D[20.16427] → [6.52672:52785]
∅:D[10.29554] → [6.52672:52785]
∅:D[29.14608] → [6.52672:52785]
∅:D[21.47313] → [6.52672:52785]
∅:D[11.22076] → [6.52672:52785]
∅:D[39.10948] → [6.52672:52785]
∅:D[22.8469] → [6.52672:52785]
∅:D[31.19680] → [6.52672:52785]
∅:D[12.18812] → [6.52672:52785]
∅:D[23.11260] → [6.52672:52785]
∅:D[24.11596] → [6.52672:52785]
∅:D[7.18202] → [6.52672:52785]
∅:D[8.56492] → [6.52672:52785]
∅:D[6.52672] → [6.52672:52785]
∅:D[6.52785] → [2.67760:67779]
∅:D[25.24188] → [6.52804:52966]
∅:D[4.32620] → [6.52804:52966]
∅:D[2.67779] → [6.52804:52966]
∅:D[8.56512] → [6.52804:52966]
∅:D[6.52804] → [6.52804:52966]
∅:D[6.52966] → [7.18203:18340]
∅:D[7.18340] → [8.56513:56591]
∅:D[25.24267] → [6.52966:52981]
∅:D[27.18133] → [6.52966:52981]
∅:D[4.32699] → [6.52966:52981]
∅:D[26.21777] → [6.52966:52981]
∅:D[34.13651] → [6.52966:52981]
∅:D[36.9029] → [6.52966:52981]
∅:D[7.18418] → [6.52966:52981]
∅:D[8.56591] → [6.52966:52981]
∅:D[6.52966] → [6.52966:52981]
∅:D[6.53196] → [6.53196:53210]
∅:D[6.53210] → [8.56592:56611]
∅:D[18.29659] → [6.53229:53311]
∅:D[9.37143] → [6.53229:53311]
∅:D[14.16643] → [6.53229:53311]
∅:D[15.7288] → [6.53229:53311]
∅:D[4.32719] → [6.53229:53311]
∅:D[20.16447] → [6.53229:53311]
∅:D[10.29574] → [6.53229:53311]
∅:D[29.14628] → [6.53229:53311]
∅:D[21.47333] → [6.53229:53311]
∅:D[11.22096] → [6.53229:53311]
∅:D[39.10968] → [6.53229:53311]
∅:D[22.8489] → [6.53229:53311]
∅:D[31.19700] → [6.53229:53311]
∅:D[12.18832] → [6.53229:53311]
∅:D[23.11280] → [6.53229:53311]
∅:D[24.11616] → [6.53229:53311]
∅:D[8.56611] → [6.53229:53311]
∅:D[6.53229] → [6.53229:53311]
∅:D[6.53311] → [2.67780:68006]
∅:D[25.24494] → [6.53537:53567]
∅:D[4.32946] → [6.53537:53567]
∅:D[2.68006] → [6.53537:53567]
∅:D[8.56838] → [6.53537:53567]
∅:D[6.53537] → [6.53537:53567]
∅:D[6.53567] → [2.68007:68026]
∅:D[18.29833] → [6.53586:53668]
∅:D[25.24514] → [6.53586:53668]
∅:D[9.37317] → [6.53586:53668]
∅:D[27.18226] → [6.53586:53668]
∅:D[14.16817] → [6.53586:53668]
∅:D[4.32966] → [6.53586:53668]
∅:D[2.68026] → [6.53586:53668]
∅:D[35.7767] → [6.53586:53668]
∅:D[26.21870] → [6.53586:53668]
∅:D[10.29748] → [6.53586:53668]
∅:D[21.47507] → [6.53586:53668]
∅:D[11.22270] → [6.53586:53668]
∅:D[34.13744] → [6.53586:53668]
∅:D[12.19006] → [6.53586:53668]
∅:D[36.9122] → [6.53586:53668]
∅:D[7.18592] → [6.53586:53668]
∅:D[8.56858] → [6.53586:53668]
∅:D[6.53586] → [6.53586:53668]
∅:D[6.53668] → [2.68027:68175]
∅:D[25.24663] → [6.53816:53887]
∅:D[4.33115] → [6.53816:53887]
∅:D[2.68175] → [6.53816:53887]
∅:D[8.57007] → [6.53816:53887]
∅:D[6.53816] → [6.53816:53887]
∅:D[6.53887] → [8.57008:57084]
∅:D[37.2005] → [6.53962:54040]
∅:D[18.29909] → [6.53962:54040]
∅:D[25.24740] → [6.53962:54040]
∅:D[9.37393] → [6.53962:54040]
∅:D[27.18376] → [6.53962:54040]
∅:D[15.7518] → [6.53962:54040]
∅:D[4.33191] → [6.53962:54040]
∅:D[26.21947] → [6.53962:54040]
∅:D[20.16677] → [6.53962:54040]
∅:D[10.29824] → [6.53962:54040]
∅:D[29.14858] → [6.53962:54040]
∅:D[21.47583] → [6.53962:54040]
∅:D[11.22346] → [6.53962:54040]
∅:D[39.11198] → [6.53962:54040]
∅:D[22.8719] → [6.53962:54040]
∅:D[31.19930] → [6.53962:54040]
∅:D[34.13820] → [6.53962:54040]
∅:D[12.19082] → [6.53962:54040]
∅:D[23.11510] → [6.53962:54040]
∅:D[38.6453] → [6.53962:54040]
∅:D[36.9273] → [6.53962:54040]
∅:D[24.11846] → [6.53962:54040]
∅:D[7.18742] → [6.53962:54040]
∅:D[8.57084] → [6.53962:54040]
∅:D[6.53962] → [6.53962:54040]
∅:D[6.54040] → [2.68176:68344]
∅:D[2.68344] → [8.57253:57484]
∅:D[8.57253] → [8.57253:57484]
∅:D[8.57484] → [2.68345:68422]
∅:D[2.68422] → [8.57561:57637]
∅:D[8.57561] → [8.57561:57637]
∅:D[8.57637] → [2.68423:68507]
∅:D[2.68507] → [8.57721:57800]
∅:D[8.57721] → [8.57721:57800]
∅:D[25.25386] → [7.19073:19149]
∅:D[9.38022] → [7.19073:19149]
∅:D[4.33828] → [7.19073:19149]
∅:D[35.8003] → [7.19073:19149]
∅:D[8.57883] → [7.19073:19149]
∅:D[7.19073] → [7.19073:19149]
∅:D[7.19149] → [8.57884:57960]
∅:D[9.38099] → [7.19225:19363]
∅:D[4.33905] → [7.19225:19363]
∅:D[10.30374] → [7.19225:19363]
∅:D[12.19631] → [7.19225:19363]
∅:D[8.57960] → [7.19225:19363]
∅:D[7.19225] → [7.19225:19363]
∅:D[7.19363] → [2.68508:68583]
∅:D[25.25462] → [6.55024:55160]
∅:D[14.17680] → [6.55024:55160]
∅:D[4.33981] → [6.55024:55160]
∅:D[2.68583] → [6.55024:55160]
∅:D[7.19438] → [6.55024:55160]
∅:D[8.58036] → [6.55024:55160]
∅:D[6.55024] → [6.55024:55160]
∅:D[6.55160] → [2.68584:68732]
∅:D[2.68732] → [8.58185:58261]
∅:D[8.58185] → [8.58185:58261]
∅:D[18.30536] → [6.55384:55386]
∅:D[25.25687] → [6.55384:55386]
∅:D[9.38176] → [6.55384:55386]
∅:D[27.19009] → [6.55384:55386]
∅:D[14.17831] → [6.55384:55386]
∅:D[4.34206] → [6.55384:55386]
∅:D[26.22506] → [6.55384:55386]
∅:D[10.30451] → [6.55384:55386]
∅:D[21.48210] → [6.55384:55386]
∅:D[11.22972] → [6.55384:55386]
∅:D[34.14379] → [6.55384:55386]
∅:D[12.19708] → [6.55384:55386]
∅:D[36.9906] → [6.55384:55386]
∅:D[8.58261] → [6.55384:55386]
∅:D[6.55384] → [6.55384:55386]
∅:D[6.55386] → [40.52957:52958]
∅:D[40.52957] → [40.52957:52958]
∅:D[40.52958] → [6.55387:55429]
∅:D[6.55429] → [2.68733:68751]
∅:D[25.25706] → [6.55447:55529]
∅:D[27.19028] → [6.55447:55529]
∅:D[14.17850] → [6.55447:55529]
∅:D[4.34225] → [6.55447:55529]
∅:D[2.68751] → [6.55447:55529]
∅:D[26.22525] → [6.55447:55529]
∅:D[34.14398] → [6.55447:55529]
∅:D[36.9925] → [6.55447:55529]
∅:D[7.19531] → [6.55447:55529]
∅:D[8.58280] → [6.55447:55529]
∅:D[6.55447] → [6.55447:55529]
∅:D[6.55529] → [2.68752:68908]
∅:D[18.30618] → [6.55685:55724]
∅:D[25.25863] → [6.55685:55724]
∅:D[9.38258] → [6.55685:55724]
∅:D[14.17932] → [6.55685:55724]
∅:D[4.34382] → [6.55685:55724]
∅:D[2.68908] → [6.55685:55724]
∅:D[10.30533] → [6.55685:55724]
∅:D[21.48292] → [6.55685:55724]
∅:D[11.23054] → [6.55685:55724]
∅:D[12.19790] → [6.55685:55724]
∅:D[8.58437] → [6.55685:55724]
∅:D[6.55685] → [6.55685:55724]
∅:D[6.55724] → [2.68909:68927]
∅:D[18.30637] → [6.55742:55824]
∅:D[25.25882] → [6.55742:55824]
∅:D[9.38277] → [6.55742:55824]
∅:D[14.17951] → [6.55742:55824]
∅:D[4.34401] → [6.55742:55824]
∅:D[2.68927] → [6.55742:55824]
∅:D[10.30552] → [6.55742:55824]
∅:D[21.48311] → [6.55742:55824]
∅:D[11.23073] → [6.55742:55824]
∅:D[12.19809] → [6.55742:55824]
∅:D[8.58456] → [6.55742:55824]
∅:D[6.55742] → [6.55742:55824]
∅:D[6.55824] → [8.58457:58539]
∅:D[8.58539] → [2.68928:69003]
∅:D[25.25958] → [6.55899:55932]
∅:D[4.34477] → [6.55899:55932]
∅:D[2.69003] → [6.55899:55932]
∅:D[8.58614] → [6.55899:55932]
∅:D[6.55899] → [6.55899:55932]
∅:D[6.55932] → [8.58615:58633]
∅:D[18.30739] → [6.55950:56032]
∅:D[25.25977] → [6.55950:56032]
∅:D[9.38379] → [6.55950:56032]
∅:D[27.19047] → [6.55950:56032]
∅:D[14.17970] → [6.55950:56032]
∅:D[4.34496] → [6.55950:56032]
∅:D[26.22544] → [6.55950:56032]
∅:D[10.30654] → [6.55950:56032]
∅:D[21.48413] → [6.55950:56032]
∅:D[11.23092] → [6.55950:56032]
∅:D[34.14417] → [6.55950:56032]
∅:D[12.19828] → [6.55950:56032]
∅:D[36.9944] → [6.55950:56032]
∅:D[8.58633] → [6.55950:56032]
∅:D[6.55950] → [6.55950:56032]
∅:D[6.56032] → [2.69004:69079]
∅:D[2.69079] → [8.58709:58785]
∅:D[8.58709] → [8.58709:58785]
∅:D[8.58785] → [2.69080:69164]
∅:D[18.30900] → [6.56266:56299]
∅:D[25.26213] → [6.56266:56299]
∅:D[9.38540] → [6.56266:56299]
∅:D[27.19208] → [6.56266:56299]
∅:D[14.18130] → [6.56266:56299]
∅:D[4.34731] → [6.56266:56299]
∅:D[2.69164] → [6.56266:56299]
∅:D[26.22705] → [6.56266:56299]
∅:D[10.30815] → [6.56266:56299]
∅:D[21.48574] → [6.56266:56299]
∅:D[11.23252] → [6.56266:56299]
∅:D[34.14578] → [6.56266:56299]
∅:D[12.19988] → [6.56266:56299]
∅:D[36.10105] → [6.56266:56299]
∅:D[7.19615] → [6.56266:56299]
∅:D[8.58869] → [6.56266:56299]
∅:D[6.56266] → [6.56266:56299]
∅:D[6.56299] → [8.58870:58889]
∅:D[18.30920] → [6.56318:56400]
∅:D[25.26233] → [6.56318:56400]
∅:D[9.38560] → [6.56318:56400]
∅:D[27.19228] → [6.56318:56400]
∅:D[14.18150] → [6.56318:56400]
∅:D[4.34751] → [6.56318:56400]
∅:D[26.22725] → [6.56318:56400]
∅:D[10.30835] → [6.56318:56400]
∅:D[21.48594] → [6.56318:56400]
∅:D[11.23272] → [6.56318:56400]
∅:D[34.14598] → [6.56318:56400]
∅:D[12.20008] → [6.56318:56400]
∅:D[36.10125] → [6.56318:56400]
∅:D[8.58889] → [6.56318:56400]
∅:D[6.56318] → [6.56318:56400]
∅:D[6.56400] → [2.69165:69313]
∅:D[25.26382] → [7.19690:19760]
∅:D[4.34900] → [7.19690:19760]
∅:D[2.69313] → [7.19690:19760]
∅:D[8.59038] → [7.19690:19760]
∅:D[6.56548] → [7.19690:19760]
∅:D[14.18295] → [6.56618:56656]
∅:D[7.19760] → [6.56618:56656]
∅:D[6.56618] → [6.56618:56656]
∅:D[6.56656] → [8.59039:59057]
∅:D[18.30939] → [6.56674:56756]
∅:D[25.26401] → [6.56674:56756]
∅:D[9.38579] → [6.56674:56756]
∅:D[27.19321] → [6.56674:56756]
∅:D[14.18314] → [6.56674:56756]
∅:D[4.34919] → [6.56674:56756]
∅:D[26.22744] → [6.56674:56756]
∅:D[10.30854] → [6.56674:56756]
∅:D[21.48613] → [6.56674:56756]
∅:D[11.23291] → [6.56674:56756]
∅:D[34.14617] → [6.56674:56756]
∅:D[12.20027] → [6.56674:56756]
∅:D[36.10218] → [6.56674:56756]
∅:D[7.19779] → [6.56674:56756]
∅:D[8.59057] → [6.56674:56756]
∅:D[6.56674] → [6.56674:56756]
∅:D[6.56756] → [8.59058:59140]
∅:D[8.59140] → [2.69314:69389]
∅:D[2.69389] → [8.59215:59293]
∅:D[8.59215] → [8.59215:59293]
∅:D[25.26555] → [7.19941:20011]
∅:D[27.19400] → [7.19941:20011]
∅:D[4.35155] → [7.19941:20011]
∅:D[26.22823] → [7.19941:20011]
∅:D[34.14696] → [7.19941:20011]
∅:D[36.10297] → [7.19941:20011]
∅:D[8.59293] → [7.19941:20011]
∅:D[7.19941] → [7.19941:20011]
∅:D[14.18546] → [6.57061:57132]
∅:D[7.20011] → [6.57061:57132]
∅:D[6.57061] → [6.57061:57132]
∅:D[6.57132] → [8.59294:59519]
∅:D[8.59519] → [2.69390:69471]
∅:D[2.69471] → [8.59600:59676]
∅:D[8.59600] → [8.59600:59676]
∅:D[8.59676] → [2.69472:69549]
∅:D[18.31404] → [6.57513:57550]
∅:D[25.26867] → [6.57513:57550]
∅:D[9.39044] → [6.57513:57550]
∅:D[27.19553] → [6.57513:57550]
∅:D[14.18928] → [6.57513:57550]
∅:D[4.35537] → [6.57513:57550]
∅:D[2.69549] → [6.57513:57550]
∅:D[35.8229] → [6.57513:57550]
∅:D[26.23054] → [6.57513:57550]
∅:D[10.31319] → [6.57513:57550]
∅:D[21.49078] → [6.57513:57550]
∅:D[11.23756] → [6.57513:57550]
∅:D[34.14849] → [6.57513:57550]
∅:D[12.20492] → [6.57513:57550]
∅:D[36.10528] → [6.57513:57550]
∅:D[8.59753] → [6.57513:57550]
∅:D[6.57513] → [6.57513:57550]
∅:D[6.57550] → [7.20012:20030]
∅:D[14.18947] → [6.57568:57650]
∅:D[7.20030] → [6.57568:57650]
∅:D[6.57568] → [6.57568:57650]
∅:D[6.57650] → [2.69550:69697]
∅:D[18.31477] → [6.57797:57942]
∅:D[25.27015] → [6.57797:57942]
∅:D[9.39117] → [6.57797:57942]
∅:D[27.19626] → [6.57797:57942]
∅:D[14.19020] → [6.57797:57942]
∅:D[15.7750] → [6.57797:57942]
∅:D[4.35685] → [6.57797:57942]
∅:D[2.69697] → [6.57797:57942]
∅:D[33.8187] → [6.57797:57942]
∅:D[35.8302] → [6.57797:57942]
∅:D[26.23127] → [6.57797:57942]
∅:D[20.16909] → [6.57797:57942]
∅:D[10.31392] → [6.57797:57942]
∅:D[29.15090] → [6.57797:57942]
∅:D[21.49151] → [6.57797:57942]
∅:D[11.23829] → [6.57797:57942]
∅:D[39.11430] → [6.57797:57942]
∅:D[22.8951] → [6.57797:57942]
∅:D[31.20162] → [6.57797:57942]
∅:D[34.14922] → [6.57797:57942]
∅:D[12.20565] → [6.57797:57942]
∅:D[23.11742] → [6.57797:57942]
∅:D[36.10601] → [6.57797:57942]
∅:D[24.12078] → [6.57797:57942]
∅:D[7.20103] → [6.57797:57942]
∅:D[8.59901] → [6.57797:57942]
∅:D[6.57797] → [6.57797:57942]
∅:D[6.57942] → [8.59902:59980]
∅:D[8.59980] → [2.69698:69779]
∅:D[2.69779] → [8.60061:60217]
∅:D[8.60061] → [8.60061:60217]
∅:D[8.60217] → [2.69780:69853]
∅:D[2.69853] → [8.60290:60325]
∅:D[8.60290] → [8.60290:60325]
∅:D[8.60325] → [2.69854:69872]
∅:D[2.69872] → [8.60343:60495]
∅:D[8.60343] → [8.60343:60495]
∅:D[8.60495] → [2.69873:69948]
∅:D[25.27404] → [9.39434:39449]
∅:D[4.36074] → [9.39434:39449]
∅:D[2.69948] → [9.39434:39449]
∅:D[8.60570] → [9.39434:39449]
∅:D[6.58330] → [9.39434:39449]
∅:D[6.58345] → [6.58345:58364]
∅:D[6.58364] → [8.60571:60589]
∅:D[18.31812] → [6.58382:58464]
∅:D[9.39663] → [6.58382:58464]
∅:D[14.19355] → [6.58382:58464]
∅:D[4.36093] → [6.58382:58464]
∅:D[10.31727] → [6.58382:58464]
∅:D[21.49486] → [6.58382:58464]
∅:D[11.24164] → [6.58382:58464]
∅:D[12.20900] → [6.58382:58464]
∅:D[8.60589] → [6.58382:58464]
∅:D[6.58382] → [6.58382:58464]
∅:D[6.58464] → [2.69949:70097]
∅:D[25.27718] → [6.58612:58755]
∅:D[4.36242] → [6.58612:58755]
∅:D[2.70097] → [6.58612:58755]
∅:D[8.60738] → [6.58612:58755]
∅:D[6.58612] → [6.58612:58755]
∅:D[6.58755] → [8.60739:60895]
∅:D[18.31969] → [6.58911:58952]
∅:D[25.27875] → [6.58911:58952]
∅:D[9.39820] → [6.58911:58952]
∅:D[27.20112] → [6.58911:58952]
∅:D[14.19586] → [6.58911:58952]
∅:D[4.36399] → [6.58911:58952]
∅:D[26.23610] → [6.58911:58952]
∅:D[10.31884] → [6.58911:58952]
∅:D[21.49643] → [6.58911:58952]
∅:D[11.24321] → [6.58911:58952]
∅:D[34.15334] → [6.58911:58952]
∅:D[12.21057] → [6.58911:58952]
∅:D[36.11158] → [6.58911:58952]
∅:D[7.20418] → [6.58911:58952]
∅:D[8.60895] → [6.58911:58952]
∅:D[6.58911] → [6.58911:58952]
∅:D[6.58952] → [2.70098:70117]
∅:D[18.31989] → [6.58970:59052]
∅:D[25.27895] → [6.58970:59052]
∅:D[9.39840] → [6.58970:59052]
∅:D[27.20132] → [6.58970:59052]
∅:D[14.19605] → [6.58970:59052]
∅:D[4.36418] → [6.58970:59052]
∅:D[2.70117] → [6.58970:59052]
∅:D[26.23630] → [6.58970:59052]
∅:D[10.31904] → [6.58970:59052]
∅:D[21.49663] → [6.58970:59052]
∅:D[11.24340] → [6.58970:59052]
∅:D[34.15354] → [6.58970:59052]
∅:D[12.21076] → [6.58970:59052]
∅:D[36.11178] → [6.58970:59052]
∅:D[7.20437] → [6.58970:59052]
∅:D[8.60915] → [6.58970:59052]
∅:D[6.58970] → [6.58970:59052]
∅:D[6.59052] → [8.60916:61162]
∅:D[8.61162] → [2.70118:70193]
∅:D[25.28136] → [7.20603:20673]
∅:D[4.36658] → [7.20603:20673]
∅:D[2.70193] → [7.20603:20673]
∅:D[8.61237] → [7.20603:20673]
∅:D[6.59291] → [7.20603:20673]
∅:D[7.20673] → [8.61238:61456]
∅:D[8.61456] → [2.70194:70275]
∅:D[18.32466] → [6.59588:59624]
∅:D[25.28295] → [6.59588:59624]
∅:D[9.40464] → [6.59588:59624]
∅:D[14.20068] → [6.59588:59624]
∅:D[4.36886] → [6.59588:59624]
∅:D[2.70275] → [6.59588:59624]
∅:D[10.32381] → [6.59588:59624]
∅:D[21.50140] → [6.59588:59624]
∅:D[11.24733] → [6.59588:59624]
∅:D[12.21469] → [6.59588:59624]
∅:D[8.61537] → [6.59588:59624]
∅:D[6.59588] → [6.59588:59624]
∅:D[6.59624] → [8.61538:61557]
∅:D[9.40484] → [6.59642:59724]
∅:D[14.20087] → [6.59642:59724]
∅:D[4.36905] → [6.59642:59724]
∅:D[7.20764] → [6.59642:59724]
∅:D[8.61557] → [6.59642:59724]
∅:D[6.59642] → [6.59642:59724]
∅:D[6.59724] → [8.61558:61640]
∅:D[8.61640] → [2.70276:70351]
∅:D[2.70351] → [8.61715:61786]
∅:D[8.61715] → [8.61715:61786]
∅:D[8.61786] → [2.70352:70433]
∅:D[18.32702] → [6.60033:60067]
∅:D[25.28453] → [6.60033:60067]
∅:D[9.40720] → [6.60033:60067]
∅:D[14.20323] → [6.60033:60067]
∅:D[4.37215] → [6.60033:60067]
∅:D[2.70433] → [6.60033:60067]
∅:D[10.32617] → [6.60033:60067]
∅:D[21.50376] → [6.60033:60067]
∅:D[11.24969] → [6.60033:60067]
∅:D[12.21705] → [6.60033:60067]
∅:D[8.61867] → [6.60033:60067]
∅:D[6.60033] → [6.60033:60067]
∅:D[6.60067] → [8.61868:61886]
∅:D[18.32721] → [6.60085:60167]
∅:D[9.40739] → [6.60085:60167]
∅:D[14.20342] → [6.60085:60167]
∅:D[4.37234] → [6.60085:60167]
∅:D[10.32636] → [6.60085:60167]
∅:D[21.50395] → [6.60085:60167]
∅:D[11.24988] → [6.60085:60167]
∅:D[12.21724] → [6.60085:60167]
∅:D[8.61886] → [6.60085:60167]
∅:D[6.60085] → [6.60085:60167]
∅:D[6.60167] → [2.70434:70509]
∅:D[25.28529] → [6.60242:60319]
∅:D[4.37310] → [6.60242:60319]
∅:D[2.70509] → [6.60242:60319]
∅:D[8.61962] → [6.60242:60319]
∅:D[6.60242] → [6.60242:60319]
∅:D[6.60319] → [8.61963:62039]
∅:D[18.32798] → [6.60395:60410]
∅:D[25.28825] → [6.60395:60410]
∅:D[9.40816] → [6.60395:60410]
∅:D[27.20528] → [6.60395:60410]
∅:D[14.20419] → [6.60395:60410]
∅:D[4.37387] → [6.60395:60410]
∅:D[26.23949] → [6.60395:60410]
∅:D[10.32713] → [6.60395:60410]
∅:D[21.50472] → [6.60395:60410]
∅:D[11.25065] → [6.60395:60410]
∅:D[34.15750] → [6.60395:60410]
∅:D[12.21801] → [6.60395:60410]
∅:D[36.11497] → [6.60395:60410]
∅:D[8.62258] → [6.60395:60410]
∅:D[6.60395] → [6.60395:60410]
∅:D[35.8615] → [6.60410:60429]
∅:D[6.60410] → [6.60410:60429]
∅:D[6.60429] → [7.20848:20866]
∅:D[14.20438] → [6.60447:60529]
∅:D[7.20866] → [6.60447:60529]
∅:D[6.60447] → [6.60447:60529]
∅:D[6.60529] → [2.70510:70658]
∅:D[25.28974] → [7.20941:21011]
∅:D[4.37536] → [7.20941:21011]
∅:D[2.70658] → [7.20941:21011]
∅:D[8.62407] → [7.20941:21011]
∅:D[6.60677] → [7.20941:21011]
∅:D[14.20583] → [6.60747:60896]
∅:D[7.21011] → [6.60747:60896]
∅:D[6.60747] → [6.60747:60896]
∅:D[6.60896] → [8.62408:62564]
∅:D[18.32955] → [6.61052:61086]
∅:D[25.29131] → [6.61052:61086]
∅:D[9.40973] → [6.61052:61086]
∅:D[27.20759] → [6.61052:61086]
∅:D[14.20740] → [6.61052:61086]
∅:D[4.37693] → [6.61052:61086]
∅:D[26.24106] → [6.61052:61086]
∅:D[10.32870] → [6.61052:61086]
∅:D[21.50629] → [6.61052:61086]
∅:D[11.25222] → [6.61052:61086]
∅:D[34.15907] → [6.61052:61086]
∅:D[12.21958] → [6.61052:61086]
∅:D[36.11728] → [6.61052:61086]
∅:D[7.21092] → [6.61052:61086]
∅:D[8.62564] → [6.61052:61086]
∅:D[6.61052] → [6.61052:61086]
∅:D[6.61086] → [8.62565:62583]
∅:D[18.32974] → [6.61104:61186]
∅:D[9.40992] → [6.61104:61186]
∅:D[14.20759] → [6.61104:61186]
∅:D[4.37712] → [6.61104:61186]
∅:D[10.32889] → [6.61104:61186]
∅:D[21.50648] → [6.61104:61186]
∅:D[11.25241] → [6.61104:61186]
∅:D[12.21977] → [6.61104:61186]
∅:D[7.21111] → [6.61104:61186]
∅:D[8.62583] → [6.61104:61186]
∅:D[6.61104] → [6.61104:61186]
∅:D[6.61186] → [2.70659:70807]
∅:D[25.29280] → [6.61334:61406]
∅:D[4.37861] → [6.61334:61406]
∅:D[2.70807] → [6.61334:61406]
∅:D[8.62732] → [6.61334:61406]
∅:D[6.61334] → [6.61334:61406]
∅:D[6.61406] → [2.70808:70880]
∅:D[25.29353] → [7.21258:21328]
∅:D[9.41065] → [7.21258:21328]
∅:D[27.20906] → [7.21258:21328]
∅:D[4.37934] → [7.21258:21328]
∅:D[2.70880] → [7.21258:21328]
∅:D[33.8482] → [7.21258:21328]
∅:D[35.8836] → [7.21258:21328]
∅:D[26.24179] → [7.21258:21328]
∅:D[10.32962] → [7.21258:21328]
∅:D[34.15980] → [7.21258:21328]
∅:D[12.22050] → [7.21258:21328]
∅:D[36.11875] → [7.21258:21328]
∅:D[8.62805] → [7.21258:21328]
∅:D[7.21258] → [7.21258:21328]
∅:D[14.20976] → [6.61548:61693]
∅:D[7.21328] → [6.61548:61693]
∅:D[6.61548] → [6.61548:61693]
∅:D[6.61693] → [7.21329:21407]
∅:D[7.21407] → [8.62806:62962]
∅:D[18.33204] → [6.61927:61962]
∅:D[25.29510] → [6.61927:61962]
∅:D[9.41222] → [6.61927:61962]
∅:D[27.21063] → [6.61927:61962]
∅:D[14.21133] → [6.61927:61962]
∅:D[4.38091] → [6.61927:61962]
∅:D[26.24336] → [6.61927:61962]
∅:D[10.33119] → [6.61927:61962]
∅:D[21.50878] → [6.61927:61962]
∅:D[11.25471] → [6.61927:61962]
∅:D[34.16137] → [6.61927:61962]
∅:D[12.22207] → [6.61927:61962]
∅:D[36.12032] → [6.61927:61962]
∅:D[7.21488] → [6.61927:61962]
∅:D[8.62962] → [6.61927:61962]
∅:D[6.61927] → [6.61927:61962]
∅:D[6.61962] → [8.62963:62981]
∅:D[18.33223] → [6.61980:62062]
∅:D[9.41241] → [6.61980:62062]
∅:D[14.21152] → [6.61980:62062]
∅:D[15.8245] → [6.61980:62062]
∅:D[4.38110] → [6.61980:62062]
∅:D[20.17404] → [6.61980:62062]
∅:D[10.33138] → [6.61980:62062]
∅:D[29.15585] → [6.61980:62062]
∅:D[21.50897] → [6.61980:62062]
∅:D[11.25490] → [6.61980:62062]
∅:D[31.20657] → [6.61980:62062]
∅:D[12.22226] → [6.61980:62062]
∅:D[23.12237] → [6.61980:62062]
∅:D[24.12573] → [6.61980:62062]
∅:D[8.62981] → [6.61980:62062]
∅:D[6.61980] → [6.61980:62062]
∅:D[6.62062] → [2.70881:70954]
∅:D[25.29584] → [6.62135:62214]
∅:D[27.21137] → [6.62135:62214]
∅:D[14.21226] → [6.62135:62214]
∅:D[4.38184] → [6.62135:62214]
∅:D[2.70954] → [6.62135:62214]
∅:D[33.8556] → [6.62135:62214]
∅:D[35.8910] → [6.62135:62214]
∅:D[36.12106] → [6.62135:62214]
∅:D[7.21562] → [6.62135:62214]
∅:D[8.63055] → [6.62135:62214]
∅:D[6.62135] → [6.62135:62214]
∅:D[6.62214] → [2.70955:71030]
∅:D[25.29660] → [6.62289:62360]
∅:D[4.38260] → [6.62289:62360]
∅:D[2.71030] → [6.62289:62360]
∅:D[8.63131] → [6.62289:62360]
∅:D[6.62289] → [6.62289:62360]
∅:D[14.21371] → [6.62504:62581]
∅:D[4.38405] → [6.62504:62581]
∅:D[11.25635] → [6.62504:62581]
∅:D[12.22371] → [6.62504:62581]
∅:D[6.62504] → [6.62504:62581]
∅:D[6.62581] → [8.63132:63280]
∅:D[8.63280] → [2.71031:71104]
∅:D[18.33445] → [6.62802:62880]
∅:D[25.29812] → [6.62802:62880]
∅:D[9.41463] → [6.62802:62880]
∅:D[27.21289] → [6.62802:62880]
∅:D[14.21593] → [6.62802:62880]
∅:D[4.38627] → [6.62802:62880]
∅:D[2.71104] → [6.62802:62880]
∅:D[35.8984] → [6.62802:62880]
∅:D[26.24488] → [6.62802:62880]
∅:D[10.33360] → [6.62802:62880]
∅:D[21.51119] → [6.62802:62880]
∅:D[11.25857] → [6.62802:62880]
∅:D[34.16289] → [6.62802:62880]
∅:D[12.22593] → [6.62802:62880]
∅:D[36.12258] → [6.62802:62880]
∅:D[7.21636] → [6.62802:62880]
∅:D[8.63353] → [6.62802:62880]
∅:D[6.62802] → [6.62802:62880]
∅:D[6.62880] → [8.63354:63674]
∅:D[9.41784] → [7.21637:21713]
∅:D[4.39022] → [7.21637:21713]
∅:D[10.33681] → [7.21637:21713]
∅:D[12.22988] → [7.21637:21713]
∅:D[8.63674] → [7.21637:21713]
∅:D[14.21988] → [7.21637:21713]
∅:D[7.21713] → [8.63675:63755]
∅:D[18.33847] → [6.63430:63459]
∅:D[9.41865] → [6.63430:63459]
∅:D[14.22144] → [6.63430:63459]
∅:D[4.39103] → [6.63430:63459]
∅:D[10.33762] → [6.63430:63459]
∅:D[21.51521] → [6.63430:63459]
∅:D[11.26333] → [6.63430:63459]
∅:D[12.23069] → [6.63430:63459]
∅:D[8.63755] → [6.63430:63459]
∅:D[6.63430] → [6.63430:63459]
∅:D[6.63459] → [2.71105:71124]
∅:D[25.29908] → [6.63478:63560]
∅:D[27.21386] → [6.63478:63560]
∅:D[14.22163] → [6.63478:63560]
∅:D[4.39123] → [6.63478:63560]
∅:D[2.71124] → [6.63478:63560]
∅:D[35.9003] → [6.63478:63560]
∅:D[7.21733] → [6.63478:63560]
∅:D[8.63774] → [6.63478:63560]
∅:D[6.63478] → [6.63478:63560]
∅:D[6.63560] → [2.71125:71198]
∅:D[37.2233] → [6.63633:63673]
∅:D[18.33921] → [6.63633:63673]
∅:D[25.29982] → [6.63633:63673]
∅:D[9.41939] → [6.63633:63673]
∅:D[27.21460] → [6.63633:63673]
∅:D[14.22237] → [6.63633:63673]
∅:D[15.8319] → [6.63633:63673]
∅:D[4.39197] → [6.63633:63673]
∅:D[2.71198] → [6.63633:63673]
∅:D[26.24639] → [6.63633:63673]
∅:D[20.17478] → [6.63633:63673]
∅:D[10.33836] → [6.63633:63673]
∅:D[29.15659] → [6.63633:63673]
∅:D[21.51595] → [6.63633:63673]
∅:D[11.26407] → [6.63633:63673]
∅:D[39.11901] → [6.63633:63673]
∅:D[22.9422] → [6.63633:63673]
∅:D[31.20731] → [6.63633:63673]
∅:D[34.16440] → [6.63633:63673]
∅:D[12.23143] → [6.63633:63673]
∅:D[23.12311] → [6.63633:63673]
∅:D[38.6679] → [6.63633:63673]
∅:D[36.12409] → [6.63633:63673]
∅:D[24.12647] → [6.63633:63673]
∅:D[8.63848] → [6.63633:63673]
∅:D[6.63633] → [6.63633:63673]
∅:D[6.63673] → [8.63849:63867]
∅:D[18.33940] → [6.63691:63773]
∅:D[9.41958] → [6.63691:63773]
∅:D[14.22256] → [6.63691:63773]
∅:D[4.39216] → [6.63691:63773]
∅:D[10.33855] → [6.63691:63773]
∅:D[21.51614] → [6.63691:63773]
∅:D[11.26426] → [6.63691:63773]
∅:D[12.23162] → [6.63691:63773]
∅:D[8.63867] → [6.63691:63773]
∅:D[6.63691] → [6.63691:63773]
∅:D[6.63773] → [8.63868:64018]
∅:D[8.64018] → [2.71199:71274]
∅:D[25.30058] → [6.64003:64074]
∅:D[4.39447] → [6.64003:64074]
∅:D[2.71274] → [6.64003:64074]
∅:D[8.64093] → [6.64003:64074]
∅:D[6.64003] → [6.64003:64074]
∅:D[6.64074] → [8.64094:64172]
∅:D[25.30137] → [7.21812:21882]
∅:D[27.21539] → [7.21812:21882]
∅:D[4.39526] → [7.21812:21882]
∅:D[26.24718] → [7.21812:21882]
∅:D[34.16519] → [7.21812:21882]
∅:D[36.12488] → [7.21812:21882]
∅:D[8.64172] → [7.21812:21882]
∅:D[7.21812] → [7.21812:21882]
∅:D[7.21882] → [8.64173:64319]
∅:D[37.2309] → [6.64368:64442]
∅:D[18.34238] → [6.64368:64442]
∅:D[25.30213] → [6.64368:64442]
∅:D[9.42256] → [6.64368:64442]
∅:D[27.21615] → [6.64368:64442]
∅:D[14.22707] → [6.64368:64442]
∅:D[15.8395] → [6.64368:64442]
∅:D[4.39673] → [6.64368:64442]
∅:D[26.24794] → [6.64368:64442]
∅:D[20.17554] → [6.64368:64442]
∅:D[10.34153] → [6.64368:64442]
∅:D[29.15735] → [6.64368:64442]
∅:D[21.51912] → [6.64368:64442]
∅:D[11.26729] → [6.64368:64442]
∅:D[39.11977] → [6.64368:64442]
∅:D[22.9498] → [6.64368:64442]
∅:D[31.20807] → [6.64368:64442]
∅:D[34.16595] → [6.64368:64442]
∅:D[12.23465] → [6.64368:64442]
∅:D[23.12387] → [6.64368:64442]
∅:D[38.6755] → [6.64368:64442]
∅:D[36.12564] → [6.64368:64442]
∅:D[24.12723] → [6.64368:64442]
∅:D[7.21958] → [6.64368:64442]
∅:D[8.64319] → [6.64368:64442]
∅:D[6.64368] → [6.64368:64442]
∅:D[6.64442] → [2.71275:71356]
∅:D[2.71356] → [8.64401:64712]
∅:D[8.64401] → [8.64401:64712]
∅:D[9.42649] → [7.22118:22264]
∅:D[4.40065] → [7.22118:22264]
∅:D[8.64712] → [7.22118:22264]
∅:D[7.22118] → [7.22118:22264]
∅:D[14.23245] → [6.64979:65022]
∅:D[7.22264] → [6.64979:65022]
∅:D[6.64979] → [6.64979:65022]
∅:D[6.65022] → [8.64713:64732]
∅:D[18.34572] → [6.65040:65122]
∅:D[9.42669] → [6.65040:65122]
∅:D[14.23264] → [6.65040:65122]
∅:D[4.40084] → [6.65040:65122]
∅:D[10.34487] → [6.65040:65122]
∅:D[21.52246] → [6.65040:65122]
∅:D[11.27062] → [6.65040:65122]
∅:D[12.23798] → [6.65040:65122]
∅:D[8.64732] → [6.65040:65122]
∅:D[6.65040] → [6.65040:65122]
∅:D[6.65122] → [2.71357:71430]
∅:D[2.71430] → [8.64806:64880]
∅:D[8.64806] → [8.64806:64880]
∅:D[8.64880] → [2.71431:71506]
∅:D[25.30601] → [7.22265:22340]
∅:D[4.40312] → [7.22265:22340]
∅:D[2.71506] → [7.22265:22340]
∅:D[8.64955] → [7.22265:22340]
∅:D[6.65349] → [7.22265:22340]
∅:D[7.22340] → [8.64956:65034]
∅:D[25.30680] → [7.22418:22488]
∅:D[27.21925] → [7.22418:22488]
∅:D[4.40391] → [7.22418:22488]
∅:D[26.25030] → [7.22418:22488]
∅:D[34.16831] → [7.22418:22488]
∅:D[36.12874] → [7.22418:22488]
∅:D[8.65034] → [7.22418:22488]
∅:D[7.22418] → [7.22418:22488]
∅:D[7.22488] → [2.71507:71583]
∅:D[2.71583] → [8.65111:65264]
∅:D[8.65111] → [8.65111:65264]
∅:D[8.65264] → [2.71584:71657]
∅:D[2.71657] → [8.65337:65419]
∅:D[8.65337] → [8.65337:65419]
∅:D[18.34956] → [6.65956:66103]
∅:D[9.43053] → [6.65956:66103]
∅:D[14.23877] → [6.65956:66103]
∅:D[4.40776] → [6.65956:66103]
∅:D[10.34871] → [6.65956:66103]
∅:D[21.52630] → [6.65956:66103]
∅:D[11.27451] → [6.65956:66103]
∅:D[12.24187] → [6.65956:66103]
∅:D[8.65419] → [6.65956:66103]
∅:D[6.65956] → [6.65956:66103]
∅:D[6.66103] → [8.65420:65438]
∅:D[18.34975] → [6.66121:66186]
∅:D[9.43072] → [6.66121:66186]
∅:D[14.23896] → [6.66121:66186]
∅:D[4.40795] → [6.66121:66186]
∅:D[10.34890] → [6.66121:66186]
∅:D[21.52649] → [6.66121:66186]
∅:D[11.27470] → [6.66121:66186]
∅:D[12.24206] → [6.66121:66186]
∅:D[8.65438] → [6.66121:66186]
∅:D[6.66121] → [6.66121:66186]
∅:D[6.66186] → [8.65439:65456]
∅:D[8.65456] → [2.71658:71731]
∅:D[2.71731] → [8.65529:65531]
∅:D[8.65529] → [8.65529:65531]
∅:D[18.35068] → [6.66186:66235]
∅:D[9.43165] → [6.66186:66235]
∅:D[10.34983] → [6.66186:66235]
∅:D[21.52742] → [6.66186:66235]
∅:D[8.65531] → [6.66186:66235]
∅:D[6.66186] → [6.66186:66235]
∅:D[6.66235] → [7.22638:22752]
∅:D[7.22752] → [6.66349:66669]
∅:D[6.66349] → [6.66349:66669]
∅:D[6.66669] → [8.65532:65550]
∅:D[9.43184] → [6.66687:66752]
∅:D[4.40814] → [6.66687:66752]
∅:D[8.65550] → [6.66687:66752]
∅:D[6.66687] → [6.66687:66752]
∅:D[6.66752] → [8.65551:65645]
∅:D[9.43279] → [6.66752:67040]
∅:D[8.65645] → [6.66752:67040]
∅:D[6.66752] → [6.66752:67040]
∅:D[38.6947] → [38.6947:7012]
∅:D[38.7102] → [38.7102:7115]
∅:D[27.22509] → [6.67325:67338]
∅:D[4.41022] → [6.67325:67338]
∅:D[34.17264] → [6.67325:67338]
∅:D[38.7115] → [6.67325:67338]
∅:D[6.67325] → [6.67325:67338]
∅:D[6.67338] → [7.22753:22771]
∅:D[14.23915] → [6.67356:67696]
∅:D[7.22771] → [6.67356:67696]
∅:D[6.67356] → [6.67356:67696]
∅:D[6.67696] → [8.65646:65664]
∅:D[9.43298] → [7.22772:22889]
∅:D[4.41041] → [7.22772:22889]
∅:D[10.35002] → [7.22772:22889]
∅:D[12.24225] → [7.22772:22889]
∅:D[8.65664] → [7.22772:22889]
∅:D[14.23934] → [7.22772:22889]
∅:D[18.35087] → [6.67714:67792]
∅:D[14.23934] → [6.67714:67792]
∅:D[21.52761] → [6.67714:67792]
∅:D[11.27489] → [6.67714:67792]
∅:D[7.22889] → [6.67714:67792]
∅:D[6.67714] → [6.67714:67792]
∅:D[6.67909] → [6.67909:68055]
∅:D[4.41271] → [6.68284:68362]
∅:D[34.17375] → [6.68284:68362]
∅:D[38.7226] → [6.68284:68362]
∅:D[6.68284] → [6.68284:68362]
∅:D[27.22620] → [6.68362:68476]
∅:D[6.68362] → [6.68362:68476]
∅:D[6.68476] → [2.71732:71807]
∅:D[25.31132] → [7.22890:22960]
∅:D[4.41347] → [7.22890:22960]
∅:D[2.71807] → [7.22890:22960]
∅:D[8.65740] → [7.22890:22960]
∅:D[6.68551] → [7.22890:22960]
∅:D[14.24125] → [6.68621:68955]
∅:D[7.22960] → [6.68621:68955]
∅:D[6.68621] → [6.68621:68955]
∅:D[6.68955] → [2.71808:71826]
∅:D[25.31151] → [6.68973:69508]
∅:D[4.41366] → [6.68973:69508]
∅:D[2.71826] → [6.68973:69508]
∅:D[8.65759] → [6.68973:69508]
∅:D[6.68973] → [6.68973:69508]
∅:D[6.69508] → [7.22961:22982]
∅:D[7.22982] → [8.65760:65778]
∅:D[9.43317] → [7.23000:23082]
∅:D[4.41385] → [7.23000:23082]
∅:D[8.65778] → [7.23000:23082]
∅:D[7.23000] → [7.23000:23082]
∅:D[7.23082] → [2.71827:71900]
∅:D[25.31225] → [7.23155:23170]
∅:D[4.41459] → [7.23155:23170]
∅:D[2.71900] → [7.23155:23170]
∅:D[8.65852] → [7.23155:23170]
∅:D[7.23155] → [7.23155:23170]
∅:D[7.23170] → [6.69717:69773]
∅:D[6.69717] → [6.69717:69773]
∅:D[6.69773] → [7.23171:23285]
∅:D[7.23285] → [6.69773:69838]
∅:D[6.69773] → [6.69773:69838]
∅:D[6.69838] → [7.23286:23303]
∅:D[7.23303] → [2.71901:71974]
∅:D[2.71974] → [8.65926:66004]
∅:D[8.65926] → [8.65926:66004]
∅:D[9.43396] → [7.23454:23456]
∅:D[4.41611] → [7.23454:23456]
∅:D[8.66004] → [7.23454:23456]
∅:D[7.23454] → [7.23454:23456]
∅:D[7.23456] → [6.70122:70251]
∅:D[6.70122] → [6.70122:70251]
∅:D[6.70251] → [2.71975:72048]
∅:D[25.31373] → [6.70324:70456]
∅:D[4.41685] → [6.70324:70456]
∅:D[2.72048] → [6.70324:70456]
∅:D[8.66078] → [6.70324:70456]
∅:D[6.70324] → [6.70324:70456]
∅:D[6.70456] → [2.72049:72122]
∅:D[25.31447] → [6.70529:70849]
∅:D[4.41759] → [6.70529:70849]
∅:D[2.72122] → [6.70529:70849]
∅:D[8.66152] → [6.70529:70849]
∅:D[6.70529] → [6.70529:70849]
∅:D[6.70849] → [7.23457:23476]
∅:D[14.24145] → [6.70868:70950]
∅:D[7.23476] → [6.70868:70950]
∅:D[6.70868] → [6.70868:70950]
∅:D[6.70950] → [7.23477:23547]
∅:D[14.24216] → [6.71020:71090]
∅:D[7.23547] → [6.71020:71090]
∅:D[6.71020] → [6.71020:71090]
∅:D[6.71090] → [8.66153:66303]
∅:D[4.41910] → [25.31448:31485]
∅:D[8.66303] → [25.31448:31485]
∅:D[9.44223] → [25.31448:31485]
∅:D[25.31485] → [8.66304:66323]
∅:D[4.41930] → [25.31504:31586]
∅:D[8.66323] → [25.31504:31586]
∅:D[25.31504] → [25.31504:31586]
∅:D[25.31586] → [8.66324:66471]
∅:D[4.42077] → [25.31733:31806]
∅:D[8.66471] → [25.31733:31806]
∅:D[25.31733] → [25.31733:31806]
∅:D[25.31806] → [8.66472:66979]
∅:D[18.35914] → [6.72103:72106]
∅:D[25.32238] → [6.72103:72106]
∅:D[9.44223] → [6.72103:72106]
∅:D[14.25041] → [6.72103:72106]
∅:D[4.42584] → [6.72103:72106]
∅:D[10.35829] → [6.72103:72106]
∅:D[21.53588] → [6.72103:72106]
∅:D[11.28434] → [6.72103:72106]
∅:D[12.25170] → [6.72103:72106]
∅:D[8.67769] → [6.72103:72106]
∅:D[6.72103] → [6.72103:72106]
∅:D[35.10168] → [6.72106:72117]
∅:D[6.72106] → [6.72106:72117]
∅:D[6.72117] → [8.67770:67925]
∅:D[8.67925] → [2.72123:72279]
∅:D[37.2618] → [6.72272:72425]
∅:D[25.32394] → [6.72272:72425]
∅:D[27.22776] → [6.72272:72425]
∅:D[4.42740] → [6.72272:72425]
∅:D[2.72279] → [6.72272:72425]
∅:D[26.25412] → [6.72272:72425]
∅:D[34.17531] → [6.72272:72425]
∅:D[38.7382] → [6.72272:72425]
∅:D[36.13330] → [6.72272:72425]
∅:D[7.23703] → [6.72272:72425]
∅:D[8.68080] → [6.72272:72425]
∅:D[6.72272] → [6.72272:72425]
∅:D[6.72425] → [2.72280:72431]
∅:D[2.72431] → [8.68233:68385]
∅:D[8.68233] → [8.68233:68385]
∅:D[18.36374] → [6.72878:73026]
∅:D[9.44683] → [6.72878:73026]
∅:D[14.25495] → [6.72878:73026]
∅:D[15.9083] → [6.72878:73026]
∅:D[4.43194] → [6.72878:73026]
∅:D[20.18242] → [6.72878:73026]
∅:D[10.36289] → [6.72878:73026]
∅:D[29.16423] → [6.72878:73026]
∅:D[21.54048] → [6.72878:73026]
∅:D[11.28888] → [6.72878:73026]
∅:D[39.12356] → [6.72878:73026]
∅:D[22.9877] → [6.72878:73026]
∅:D[31.21338] → [6.72878:73026]
∅:D[12.25624] → [6.72878:73026]
∅:D[23.12918] → [6.72878:73026]
∅:D[24.13254] → [6.72878:73026]
∅:D[7.24007] → [6.72878:73026]
∅:D[8.68385] → [6.72878:73026]
∅:D[6.72878] → [6.72878:73026]
∅:D[6.73026] → [8.68386:68536]
∅:D[8.68536] → [2.72432:72585]
∅:D[2.72585] → [8.68689:68996]
∅:D[8.68689] → [8.68689:68996]
∅:D[18.36985] → [6.73636:73787]
∅:D[9.45294] → [6.73636:73787]
∅:D[14.26106] → [6.73636:73787]
∅:D[4.43805] → [6.73636:73787]
∅:D[10.36900] → [6.73636:73787]
∅:D[21.54659] → [6.73636:73787]
∅:D[11.29499] → [6.73636:73787]
∅:D[12.26235] → [6.73636:73787]
∅:D[8.68996] → [6.73636:73787]
∅:D[6.73636] → [6.73636:73787]
∅:D[6.73787] → [8.68997:69762]
∅:D[8.69762] → [2.72586:72735]
∅:D[25.33007] → [6.74545:74692]
∅:D[27.23236] → [6.74545:74692]
∅:D[14.26865] → [6.74545:74692]
∅:D[4.44564] → [6.74545:74692]
∅:D[2.72735] → [6.74545:74692]
∅:D[33.8854] → [6.74545:74692]
∅:D[35.10318] → [6.74545:74692]
∅:D[36.13790] → [6.74545:74692]
∅:D[7.24157] → [6.74545:74692]
∅:D[8.69911] → [6.74545:74692]
∅:D[6.74545] → [6.74545:74692]
∅:D[6.74692] → [2.72736:73031]
∅:D[25.33303] → [6.74987:75136]
∅:D[27.23532] → [6.74987:75136]
∅:D[4.44860] → [6.74987:75136]
∅:D[2.73031] → [6.74987:75136]
∅:D[33.9004] → [6.74987:75136]
∅:D[35.10614] → [6.74987:75136]
∅:D[36.14086] → [6.74987:75136]
∅:D[8.70207] → [6.74987:75136]
∅:D[6.74987] → [6.74987:75136]
∅:D[6.75136] → [2.73032:73180]
∅:D[25.33452] → [6.75284:75435]
∅:D[4.45009] → [6.75284:75435]
∅:D[2.73180] → [6.75284:75435]
∅:D[8.70356] → [6.75284:75435]
∅:D[6.75284] → [6.75284:75435]
∅:D[14.27172] → [6.75594:75914]
∅:D[4.45169] → [6.75594:75914]
∅:D[11.30416] → [6.75594:75914]
∅:D[12.27152] → [6.75594:75914]
∅:D[6.75594] → [6.75594:75914]
∅:D[6.75914] → [8.70357:71142]
∅:D[18.38686] → [6.76695:76850]
∅:D[9.47147] → [6.76695:76850]
∅:D[14.27954] → [6.76695:76850]
∅:D[4.45951] → [6.76695:76850]
∅:D[10.38601] → [6.76695:76850]
∅:D[21.56360] → [6.76695:76850]
∅:D[11.31198] → [6.76695:76850]
∅:D[12.27934] → [6.76695:76850]
∅:D[8.71142] → [6.76695:76850]
∅:D[6.76695] → [6.76695:76850]
∅:D[6.76850] → [8.71143:71447]
∅:D[8.71447] → [2.73181:73334]
∅:D[25.34079] → [6.77462:77616]
∅:D[27.24312] → [6.77462:77616]
∅:D[14.28414] → [6.77462:77616]
∅:D[4.46564] → [6.77462:77616]
∅:D[2.73334] → [6.77462:77616]
∅:D[33.9158] → [6.77462:77616]
∅:D[35.10768] → [6.77462:77616]
∅:D[11.31659] → [6.77462:77616]
∅:D[12.28395] → [6.77462:77616]
∅:D[36.14713] → [6.77462:77616]
∅:D[8.71600] → [6.77462:77616]
∅:D[6.77462] → [6.77462:77616]
∅:D[6.77616] → [8.71601:71908]
∅:D[18.39299] → [6.77923:78540]
∅:D[9.47760] → [6.77923:78540]
∅:D[14.28722] → [6.77923:78540]
∅:D[4.46872] → [6.77923:78540]
∅:D[10.39214] → [6.77923:78540]
∅:D[29.17971] → [6.77923:78540]
∅:D[21.56973] → [6.77923:78540]
∅:D[11.31967] → [6.77923:78540]
∅:D[12.28703] → [6.77923:78540]
∅:D[23.14314] → [6.77923:78540]
∅:D[8.71908] → [6.77923:78540]
∅:D[6.77923] → [6.77923:78540]
∅:D[6.78540] → [8.71909:72065]
∅:D[9.47917] → [6.78540:79005]
∅:D[8.72065] → [6.78540:79005]
∅:D[6.78540] → [6.78540:79005]
∅:D[6.79005] → [2.73335:73486]
∅:D[25.34231] → [6.79156:79314]
∅:D[4.47024] → [6.79156:79314]
∅:D[2.73486] → [6.79156:79314]
∅:D[8.72217] → [6.79156:79314]
∅:D[6.79156] → [6.79156:79314]
∅:D[6.79314] → [8.72218:72375]
∅:D[8.72375] → [2.73487:73633]
∅:D[2.73633] → [8.72521:72668]
∅:D[8.72521] → [8.72521:72668]
∅:D[18.39750] → [6.79616:79767]
∅:D[9.48368] → [6.79616:79767]
∅:D[14.29025] → [6.79616:79767]
∅:D[4.47327] → [6.79616:79767]
∅:D[10.39665] → [6.79616:79767]
∅:D[21.57424] → [6.79616:79767]
∅:D[11.32270] → [6.79616:79767]
∅:D[12.29006] → [6.79616:79767]
∅:D[7.25088] → [6.79616:79767]
∅:D[8.72668] → [6.79616:79767]
∅:D[6.79616] → [6.79616:79767]
∅:D[6.79767] → [2.73634:73782]
∅:D[25.34527] → [6.79915:80066]
∅:D[9.48517] → [6.79915:80066]
∅:D[27.24608] → [6.79915:80066]
∅:D[14.29174] → [6.79915:80066]
∅:D[4.47476] → [6.79915:80066]
∅:D[2.73782] → [6.79915:80066]
∅:D[26.26492] → [6.79915:80066]
∅:D[34.18764] → [6.79915:80066]
∅:D[36.14862] → [6.79915:80066]
∅:D[7.25237] → [6.79915:80066]
∅:D[8.72817] → [6.79915:80066]
∅:D[6.79915] → [6.79915:80066]
∅:D[6.80066] → [7.25238:25390]
∅:D[7.25390] → [2.73783:73933]
∅:D[37.3081] → [6.80368:80814]
∅:D[18.39901] → [6.80368:80814]
∅:D[25.34678] → [6.80368:80814]
∅:D[9.48668] → [6.80368:80814]
∅:D[27.24759] → [6.80368:80814]
∅:D[14.29325] → [6.80368:80814]
∅:D[15.10474] → [6.80368:80814]
∅:D[4.47627] → [6.80368:80814]
∅:D[2.73933] → [6.80368:80814]
∅:D[26.26643] → [6.80368:80814]
∅:D[20.19633] → [6.80368:80814]
∅:D[10.39816] → [6.80368:80814]
∅:D[29.18122] → [6.80368:80814]
∅:D[21.57575] → [6.80368:80814]
∅:D[11.32421] → [6.80368:80814]
∅:D[39.13747] → [6.80368:80814]
∅:D[22.11116] → [6.80368:80814]
∅:D[31.22577] → [6.80368:80814]
∅:D[34.18915] → [6.80368:80814]
∅:D[12.29157] → [6.80368:80814]
∅:D[23.14465] → [6.80368:80814]
∅:D[38.7845] → [6.80368:80814]
∅:D[36.15013] → [6.80368:80814]
∅:D[24.14493] → [6.80368:80814]
∅:D[7.25540] → [6.80368:80814]
∅:D[8.72968] → [6.80368:80814]
∅:D[6.80368] → [6.80368:80814]
∅:D[6.80814] → [7.25541:25692]
∅:D[14.29477] → [6.80965:81112]
∅:D[7.25692] → [6.80965:81112]
∅:D[6.80965] → [6.80965:81112]
∅:D[6.81112] → [8.72969:73115]
∅:D[18.40048] → [6.81258:81562]
∅:D[9.48815] → [6.81258:81562]
∅:D[14.29624] → [6.81258:81562]
∅:D[4.47774] → [6.81258:81562]
∅:D[10.39963] → [6.81258:81562]
∅:D[21.57722] → [6.81258:81562]
∅:D[11.32568] → [6.81258:81562]
∅:D[12.29304] → [6.81258:81562]
∅:D[8.73115] → [6.81258:81562]
∅:D[6.81258] → [6.81258:81562]
∅:D[6.81562] → [8.73116:73270]
∅:D[25.34833] → [7.25847:25998]
∅:D[27.24914] → [7.25847:25998]
∅:D[4.47929] → [7.25847:25998]
∅:D[26.26798] → [7.25847:25998]
∅:D[34.19070] → [7.25847:25998]
∅:D[36.15168] → [7.25847:25998]
∅:D[8.73270] → [7.25847:25998]
∅:D[7.25847] → [7.25847:25998]
∅:D[7.25998] → [2.73934:74240]
∅:D[25.35140] → [7.26147:26444]
∅:D[27.25221] → [7.26147:26444]
∅:D[4.48236] → [7.26147:26444]
∅:D[2.74240] → [7.26147:26444]
∅:D[35.11222] → [7.26147:26444]
∅:D[8.73577] → [7.26147:26444]
∅:D[6.82173] → [7.26147:26444]
∅:D[7.26444] → [2.74241:74393]
∅:D[25.35293] → [6.82622:82768]
∅:D[27.25374] → [6.82622:82768]
∅:D[4.48389] → [6.82622:82768]
∅:D[2.74393] → [6.82622:82768]
∅:D[35.11375] → [6.82622:82768]
∅:D[8.73730] → [6.82622:82768]
∅:D[6.82622] → [6.82622:82768]
∅:D[6.82768] → [8.73731:73885]
∅:D[18.40352] → [6.82922:83072]
∅:D[9.49119] → [6.82922:83072]
∅:D[14.30677] → [6.82922:83072]
∅:D[15.10778] → [6.82922:83072]
∅:D[4.48544] → [6.82922:83072]
∅:D[20.19937] → [6.82922:83072]
∅:D[10.40267] → [6.82922:83072]
∅:D[29.18426] → [6.82922:83072]
∅:D[21.58026] → [6.82922:83072]
∅:D[11.32872] → [6.82922:83072]
∅:D[39.14051] → [6.82922:83072]
∅:D[22.11420] → [6.82922:83072]
∅:D[31.22881] → [6.82922:83072]
∅:D[12.29608] → [6.82922:83072]
∅:D[23.14769] → [6.82922:83072]
∅:D[24.14797] → [6.82922:83072]
∅:D[8.73885] → [6.82922:83072]
∅:D[6.82922] → [6.82922:83072]
∅:D[6.83072] → [8.73886:74035]
∅:D[37.3231] → [6.83221:83373]
∅:D[18.40502] → [6.83221:83373]
∅:D[25.35443] → [6.83221:83373]
∅:D[9.49269] → [6.83221:83373]
∅:D[27.25524] → [6.83221:83373]
∅:D[14.30827] → [6.83221:83373]
∅:D[15.10928] → [6.83221:83373]
∅:D[4.48694] → [6.83221:83373]
∅:D[26.27097] → [6.83221:83373]
∅:D[20.20087] → [6.83221:83373]
∅:D[10.40417] → [6.83221:83373]
∅:D[29.18576] → [6.83221:83373]
∅:D[21.58176] → [6.83221:83373]
∅:D[11.33022] → [6.83221:83373]
∅:D[39.14201] → [6.83221:83373]
∅:D[22.11570] → [6.83221:83373]
∅:D[31.23031] → [6.83221:83373]
∅:D[34.19369] → [6.83221:83373]
∅:D[12.29758] → [6.83221:83373]
∅:D[23.14919] → [6.83221:83373]
∅:D[38.7995] → [6.83221:83373]
∅:D[36.15467] → [6.83221:83373]
∅:D[24.14947] → [6.83221:83373]
∅:D[7.26594] → [6.83221:83373]
∅:D[8.74035] → [6.83221:83373]
∅:D[6.83221] → [6.83221:83373]
∅:D[6.83373] → [8.74036:74187]
∅:D[18.40654] → [6.83523:84268]
∅:D[9.49421] → [6.83523:84268]
∅:D[14.30978] → [6.83523:84268]
∅:D[4.48845] → [6.83523:84268]
∅:D[10.40569] → [6.83523:84268]
∅:D[21.58328] → [6.83523:84268]
∅:D[11.33173] → [6.83523:84268]
∅:D[12.29909] → [6.83523:84268]
∅:D[8.74187] → [6.83523:84268]
∅:D[6.83523] → [6.83523:84268]
∅:D[6.84268] → [8.74188:74352]
∅:D[37.3396] → [7.26595:26745]
∅:D[25.35608] → [7.26595:26745]
∅:D[27.25689] → [7.26595:26745]
∅:D[4.49010] → [7.26595:26745]
∅:D[26.27262] → [7.26595:26745]
∅:D[34.19534] → [7.26595:26745]
∅:D[38.8160] → [7.26595:26745]
∅:D[36.15632] → [7.26595:26745]
∅:D[8.74352] → [7.26595:26745]
∅:D[6.84432] → [7.26595:26745]
∅:D[14.31129] → [6.84582:84890]
∅:D[7.26745] → [6.84582:84890]
∅:D[6.84582] → [6.84582:84890]
∅:D[6.84890] → [8.74353:74660]
∅:D[8.74660] → [2.74394:74546]
∅:D[18.41113] → [6.85193:85349]
∅:D[25.35914] → [6.85193:85349]
∅:D[9.49880] → [6.85193:85349]
∅:D[27.25994] → [6.85193:85349]
∅:D[14.31433] → [6.85193:85349]
∅:D[15.11232] → [6.85193:85349]
∅:D[4.49314] → [6.85193:85349]
∅:D[2.74546] → [6.85193:85349]
∅:D[35.11528] → [6.85193:85349]
∅:D[26.27568] → [6.85193:85349]
∅:D[20.20391] → [6.85193:85349]
∅:D[10.41028] → [6.85193:85349]
∅:D[29.18880] → [6.85193:85349]
∅:D[21.58787] → [6.85193:85349]
∅:D[11.33477] → [6.85193:85349]
∅:D[39.14505] → [6.85193:85349]
∅:D[22.11874] → [6.85193:85349]
∅:D[31.23335] → [6.85193:85349]
∅:D[34.19839] → [6.85193:85349]
∅:D[12.30213] → [6.85193:85349]
∅:D[23.15223] → [6.85193:85349]
∅:D[36.15938] → [6.85193:85349]
∅:D[24.15251] → [6.85193:85349]
∅:D[8.74812] → [6.85193:85349]
∅:D[6.85193] → [6.85193:85349]
∅:D[6.85349] → [2.74547:74702]
∅:D[25.36070] → [7.26746:26899]
∅:D[9.50036] → [7.26746:26899]
∅:D[27.26150] → [7.26746:26899]
∅:D[4.49470] → [7.26746:26899]
∅:D[2.74702] → [7.26746:26899]
∅:D[35.11684] → [7.26746:26899]
∅:D[26.27724] → [7.26746:26899]
∅:D[10.41184] → [7.26746:26899]
∅:D[34.19995] → [7.26746:26899]
∅:D[12.30369] → [7.26746:26899]
∅:D[36.16094] → [7.26746:26899]
∅:D[8.74968] → [7.26746:26899]
∅:D[14.31589] → [7.26746:26899]
∅:D[7.26899] → [8.74969:75431]
∅:D[18.41732] → [6.85970:86129]
∅:D[9.50499] → [6.85970:86129]
∅:D[14.32055] → [6.85970:86129]
∅:D[4.49784] → [6.85970:86129]
∅:D[10.41647] → [6.85970:86129]
∅:D[21.59406] → [6.85970:86129]
∅:D[11.33947] → [6.85970:86129]
∅:D[12.30683] → [6.85970:86129]
∅:D[8.75431] → [6.85970:86129]
∅:D[6.85970] → [6.85970:86129]
∅:D[6.86129] → [8.75432:76045]
∅:D[18.42346] → [6.86742:87055]
∅:D[9.51113] → [6.86742:87055]
∅:D[14.32669] → [6.86742:87055]
∅:D[4.50398] → [6.86742:87055]
∅:D[10.42261] → [6.86742:87055]
∅:D[21.60020] → [6.86742:87055]
∅:D[11.34561] → [6.86742:87055]
∅:D[12.31297] → [6.86742:87055]
∅:D[8.76045] → [6.86742:87055]
∅:D[6.86742] → [6.86742:87055]
∅:D[6.87055] → [8.76046:76201]
∅:D[18.42502] → [6.87210:87364]
∅:D[9.51269] → [6.87210:87364]
∅:D[14.32825] → [6.87210:87364]
∅:D[4.50554] → [6.87210:87364]
∅:D[10.42417] → [6.87210:87364]
∅:D[21.60176] → [6.87210:87364]
∅:D[11.34717] → [6.87210:87364]
∅:D[12.31453] → [6.87210:87364]
∅:D[7.27055] → [6.87210:87364]
∅:D[8.76201] → [6.87210:87364]
∅:D[6.87210] → [6.87210:87364]
∅:D[6.87364] → [8.76202:76355]
∅:D[18.42656] → [6.87517:87666]
∅:D[25.36224] → [6.87517:87666]
∅:D[9.51423] → [6.87517:87666]
∅:D[27.26304] → [6.87517:87666]
∅:D[14.32979] → [6.87517:87666]
∅:D[4.50708] → [6.87517:87666]
∅:D[26.27878] → [6.87517:87666]
∅:D[10.42571] → [6.87517:87666]
∅:D[21.60330] → [6.87517:87666]
∅:D[11.34871] → [6.87517:87666]
∅:D[34.20149] → [6.87517:87666]
∅:D[12.31607] → [6.87517:87666]
∅:D[36.16248] → [6.87517:87666]
∅:D[8.76355] → [6.87517:87666]
∅:D[6.87517] → [6.87517:87666]
∅:D[6.87666] → [2.74703:74852]
∅:D[2.74852] → [8.76505:77257]
∅:D[8.76505] → [8.76505:77257]
∅:D[9.52325] → [7.27508:27811]
∅:D[4.51757] → [7.27508:27811]
∅:D[8.77257] → [7.27508:27811]
∅:D[6.88714] → [7.27508:27811]
∅:D[7.27811] → [8.77258:77412]
∅:D[8.77412] → [2.74853:75003]
∅:D[2.75003] → [8.77562:78018]
∅:D[8.77562] → [8.77562:78018]
∅:D[8.78018] → [2.75004:75161]
∅:D[18.43722] → [6.89481:89637]
∅:D[25.36834] → [6.89481:89637]
∅:D[9.53093] → [6.89481:89637]
∅:D[14.33433] → [6.89481:89637]
∅:D[15.11546] → [6.89481:89637]
∅:D[4.52222] → [6.89481:89637]
∅:D[2.75161] → [6.89481:89637]
∅:D[20.20705] → [6.89481:89637]
∅:D[10.43637] → [6.89481:89637]
∅:D[29.19194] → [6.89481:89637]
∅:D[21.61396] → [6.89481:89637]
∅:D[11.35784] → [6.89481:89637]
∅:D[39.14819] → [6.89481:89637]
∅:D[22.12188] → [6.89481:89637]
∅:D[31.23649] → [6.89481:89637]
∅:D[12.32520] → [6.89481:89637]
∅:D[23.15537] → [6.89481:89637]
∅:D[24.15565] → [6.89481:89637]
∅:D[7.28275] → [6.89481:89637]
∅:D[8.78175] → [6.89481:89637]
∅:D[6.89481] → [6.89481:89637]
∅:D[6.89637] → [2.75162:75465]
∅:D[18.44026] → [6.89940:90097]
∅:D[25.37138] → [6.89940:90097]
∅:D[9.53397] → [6.89940:90097]
∅:D[15.11850] → [6.89940:90097]
∅:D[4.52526] → [6.89940:90097]
∅:D[2.75465] → [6.89940:90097]
∅:D[20.21009] → [6.89940:90097]
∅:D[10.43941] → [6.89940:90097]
∅:D[29.19498] → [6.89940:90097]
∅:D[21.61700] → [6.89940:90097]
∅:D[11.36088] → [6.89940:90097]
∅:D[39.15123] → [6.89940:90097]
∅:D[22.12492] → [6.89940:90097]
∅:D[31.23953] → [6.89940:90097]
∅:D[12.32824] → [6.89940:90097]
∅:D[23.15841] → [6.89940:90097]
∅:D[24.15869] → [6.89940:90097]
∅:D[7.28579] → [6.89940:90097]
∅:D[8.78479] → [6.89940:90097]
∅:D[6.89940] → [6.89940:90097]
∅:D[6.90097] → [8.78480:78634]
∅:D[8.78634] → [2.75466:75624]
∅:D[18.44339] → [6.90408:90564]
∅:D[25.37297] → [6.90408:90564]
∅:D[9.53710] → [6.90408:90564]
∅:D[14.33745] → [6.90408:90564]
∅:D[15.12009] → [6.90408:90564]
∅:D[4.52838] → [6.90408:90564]
∅:D[2.75624] → [6.90408:90564]
∅:D[20.21168] → [6.90408:90564]
∅:D[10.44254] → [6.90408:90564]
∅:D[29.19657] → [6.90408:90564]
∅:D[21.62013] → [6.90408:90564]
∅:D[11.36400] → [6.90408:90564]
∅:D[39.15282] → [6.90408:90564]
∅:D[22.12650] → [6.90408:90564]
∅:D[31.24111] → [6.90408:90564]
∅:D[12.33136] → [6.90408:90564]
∅:D[23.15999] → [6.90408:90564]
∅:D[24.16027] → [6.90408:90564]
∅:D[8.78792] → [6.90408:90564]
∅:D[6.90408] → [6.90408:90564]
∅:D[6.90564] → [7.28580:28726]
∅:D[7.28726] → [8.78793:79092]
∅:D[25.37450] → [6.91159:91312]
∅:D[27.26908] → [6.91159:91312]
∅:D[4.53288] → [6.91159:91312]
∅:D[26.28332] → [6.91159:91312]
∅:D[34.20603] → [6.91159:91312]
∅:D[36.16852] → [6.91159:91312]
∅:D[8.79092] → [6.91159:91312]
∅:D[6.91159] → [6.91159:91312]
∅:D[6.91312] → [8.79093:79419]
∅:D[18.44814] → [6.91638:91943]
∅:D[9.54185] → [6.91638:91943]
∅:D[14.34516] → [6.91638:91943]
∅:D[15.12175] → [6.91638:91943]
∅:D[4.53615] → [6.91638:91943]
∅:D[20.21334] → [6.91638:91943]
∅:D[10.44729] → [6.91638:91943]
∅:D[29.19823] → [6.91638:91943]
∅:D[21.62488] → [6.91638:91943]
∅:D[11.37025] → [6.91638:91943]
∅:D[31.24277] → [6.91638:91943]
∅:D[12.33761] → [6.91638:91943]
∅:D[23.16165] → [6.91638:91943]
∅:D[24.16193] → [6.91638:91943]
∅:D[8.79419] → [6.91638:91943]
∅:D[6.91638] → [6.91638:91943]
∅:D[6.91943] → [2.75625:75930]
∅:D[2.75930] → [8.79725:80475]
∅:D[8.79725] → [8.79725:80475]
∅:D[18.45870] → [6.92998:93150]
∅:D[25.38065] → [6.92998:93150]
∅:D[9.55241] → [6.92998:93150]
∅:D[27.27523] → [6.92998:93150]
∅:D[14.35572] → [6.92998:93150]
∅:D[15.12636] → [6.92998:93150]
∅:D[4.54671] → [6.92998:93150]
∅:D[26.28947] → [6.92998:93150]
∅:D[20.21795] → [6.92998:93150]
∅:D[10.45785] → [6.92998:93150]
∅:D[29.20284] → [6.92998:93150]
∅:D[21.63544] → [6.92998:93150]
∅:D[11.38081] → [6.92998:93150]
∅:D[31.24892] → [6.92998:93150]
∅:D[34.21218] → [6.92998:93150]
∅:D[12.34817] → [6.92998:93150]
∅:D[23.16626] → [6.92998:93150]
∅:D[36.17467] → [6.92998:93150]
∅:D[24.16654] → [6.92998:93150]
∅:D[7.29036] → [6.92998:93150]
∅:D[8.80475] → [6.92998:93150]
∅:D[6.92998] → [6.92998:93150]
∅:D[6.93150] → [8.80476:80774]
∅:D[37.4007] → [6.93448:93759]
∅:D[18.46169] → [6.93448:93759]
∅:D[25.38217] → [6.93448:93759]
∅:D[9.55540] → [6.93448:93759]
∅:D[27.27675] → [6.93448:93759]
∅:D[14.35871] → [6.93448:93759]
∅:D[15.12788] → [6.93448:93759]
∅:D[4.54970] → [6.93448:93759]
∅:D[26.29099] → [6.93448:93759]
∅:D[20.21947] → [6.93448:93759]
∅:D[10.46084] → [6.93448:93759]
∅:D[29.20436] → [6.93448:93759]
∅:D[21.63843] → [6.93448:93759]
∅:D[11.38380] → [6.93448:93759]
∅:D[39.15740] → [6.93448:93759]
∅:D[22.13108] → [6.93448:93759]
∅:D[31.25044] → [6.93448:93759]
∅:D[34.21370] → [6.93448:93759]
∅:D[12.35116] → [6.93448:93759]
∅:D[23.16778] → [6.93448:93759]
∅:D[38.8770] → [6.93448:93759]
∅:D[36.17619] → [6.93448:93759]
∅:D[24.16806] → [6.93448:93759]
∅:D[7.29188] → [6.93448:93759]
∅:D[8.80774] → [6.93448:93759]
∅:D[6.93448] → [6.93448:93759]
∅:D[6.93759] → [8.80775:80924]
∅:D[18.46319] → [6.93908:94388]
∅:D[9.55690] → [6.93908:94388]
∅:D[14.36021] → [6.93908:94388]
∅:D[4.55120] → [6.93908:94388]
∅:D[10.46234] → [6.93908:94388]
∅:D[21.63993] → [6.93908:94388]
∅:D[11.38530] → [6.93908:94388]
∅:D[12.35266] → [6.93908:94388]
∅:D[7.29338] → [6.93908:94388]
∅:D[8.80924] → [6.93908:94388]
∅:D[6.93908] → [6.93908:94388]
∅:D[6.94388] → [2.75931:76080]
∅:D[2.76080] → [8.81074:81223]
∅:D[8.81074] → [8.81074:81223]
∅:D[18.46469] → [6.94537:94685]
∅:D[9.55840] → [6.94537:94685]
∅:D[4.55270] → [6.94537:94685]
∅:D[10.46384] → [6.94537:94685]
∅:D[21.64143] → [6.94537:94685]
∅:D[8.81223] → [6.94537:94685]
∅:D[6.94537] → [6.94537:94685]
∅:D[6.94685] → [2.76081:76229]
∅:D[18.46618] → [6.94833:94982]
∅:D[25.38516] → [6.94833:94982]
∅:D[9.55989] → [6.94833:94982]
∅:D[27.27824] → [6.94833:94982]
∅:D[14.36170] → [6.94833:94982]
∅:D[15.12937] → [6.94833:94982]
∅:D[4.55419] → [6.94833:94982]
∅:D[2.76229] → [6.94833:94982]
∅:D[33.9607] → [6.94833:94982]
∅:D[35.11984] → [6.94833:94982]
∅:D[26.29248] → [6.94833:94982]
∅:D[20.22096] → [6.94833:94982]
∅:D[10.46533] → [6.94833:94982]
∅:D[29.20585] → [6.94833:94982]
∅:D[21.64292] → [6.94833:94982]
∅:D[11.38679] → [6.94833:94982]
∅:D[39.15889] → [6.94833:94982]
∅:D[22.13257] → [6.94833:94982]
∅:D[31.25193] → [6.94833:94982]
∅:D[34.21519] → [6.94833:94982]
∅:D[12.35415] → [6.94833:94982]
∅:D[23.16927] → [6.94833:94982]
∅:D[36.17768] → [6.94833:94982]
∅:D[24.16955] → [6.94833:94982]
∅:D[7.29487] → [6.94833:94982]
∅:D[8.81372] → [6.94833:94982]
∅:D[6.94833] → [6.94833:94982]
∅:D[6.94982] → [7.29488:29644]
∅:D[7.29644] → [8.81373:81674]
∅:D[9.56291] → [7.29796:29948]
∅:D[4.55721] → [7.29796:29948]
∅:D[10.46684] → [7.29796:29948]
∅:D[12.35566] → [7.29796:29948]
∅:D[8.81674] → [7.29796:29948]
∅:D[14.36628] → [7.29796:29948]
∅:D[14.36628] → [6.95591:95741]
∅:D[7.29948] → [6.95591:95741]
∅:D[6.95591] → [6.95591:95741]
∅:D[6.95741] → [2.76230:76382]
∅:D[25.38821] → [7.29949:30104]
∅:D[4.55874] → [7.29949:30104]
∅:D[2.76382] → [7.29949:30104]
∅:D[8.81827] → [7.29949:30104]
∅:D[6.95893] → [7.29949:30104]
∅:D[7.30104] → [8.81828:81976]
∅:D[8.81976] → [2.76383:76532]
∅:D[25.38971] → [7.30254:30410]
∅:D[9.56589] → [7.30254:30410]
∅:D[27.28126] → [7.30254:30410]
∅:D[4.56172] → [7.30254:30410]
∅:D[2.76532] → [7.30254:30410]
∅:D[35.12134] → [7.30254:30410]
∅:D[26.29550] → [7.30254:30410]
∅:D[10.46982] → [7.30254:30410]
∅:D[34.21821] → [7.30254:30410]
∅:D[12.35864] → [7.30254:30410]
∅:D[36.18070] → [7.30254:30410]
∅:D[8.82125] → [7.30254:30410]
∅:D[7.30254] → [7.30254:30410]
∅:D[14.36926] → [6.96501:96655]
∅:D[7.30410] → [6.96501:96655]
∅:D[6.96501] → [6.96501:96655]
∅:D[6.96655] → [2.76533:76853]
∅:D[2.76853] → [8.82446:82905]
∅:D[8.82446] → [8.82446:82905]
∅:D[25.39751] → [7.30731:30886]
∅:D[9.57206] → [7.30731:30886]
∅:D[27.28750] → [7.30731:30886]
∅:D[4.56952] → [7.30731:30886]
∅:D[26.30174] → [7.30731:30886]
∅:D[10.47599] → [7.30731:30886]
∅:D[34.22445] → [7.30731:30886]
∅:D[12.36481] → [7.30731:30886]
∅:D[36.18694] → [7.30731:30886]
∅:D[8.82905] → [7.30731:30886]
∅:D[7.30731] → [7.30731:30886]
∅:D[7.30886] → [2.76854:77007]
∅:D[2.77007] → [8.83059:83211]
∅:D[8.83059] → [8.83059:83211]
∅:D[8.83211] → [2.77008:77168]
∅:D[2.77168] → [8.83371:83678]
∅:D[8.83371] → [8.83371:83678]
∅:D[25.40226] → [7.31201:31353]
∅:D[9.57979] → [7.31201:31353]
∅:D[4.57570] → [7.31201:31353]
∅:D[35.12448] → [7.31201:31353]
∅:D[10.48065] → [7.31201:31353]
∅:D[12.36946] → [7.31201:31353]
∅:D[8.83837] → [7.31201:31353]
∅:D[14.38478] → [7.31201:31353]
∅:D[7.31353] → [8.83838:84143]
∅:D[8.84143] → [2.77169:77317]
∅:D[2.77317] → [8.84290:84610]
∅:D[8.84290] → [8.84290:84610]
∅:D[18.48777] → [6.99130:99281]
∅:D[9.58606] → [6.99130:99281]
∅:D[14.39401] → [6.99130:99281]
∅:D[4.58343] → [6.99130:99281]
∅:D[10.48692] → [6.99130:99281]
∅:D[21.66451] → [6.99130:99281]
∅:D[11.40836] → [6.99130:99281]
∅:D[12.37572] → [6.99130:99281]
∅:D[8.84610] → [6.99130:99281]
∅:D[6.99130] → [6.99130:99281]
∅:D[6.99281] → [8.84611:84762]
∅:D[18.48929] → [6.99432:99583]
∅:D[9.58758] → [6.99432:99583]
∅:D[14.39553] → [6.99432:99583]
∅:D[4.58495] → [6.99432:99583]
∅:D[10.48844] → [6.99432:99583]
∅:D[21.66603] → [6.99432:99583]
∅:D[11.40988] → [6.99432:99583]
∅:D[12.37724] → [6.99432:99583]
∅:D[8.84762] → [6.99432:99583]
∅:D[6.99432] → [6.99432:99583]
∅:D[6.99583] → [7.31655:31806]
∅:D[7.31806] → [6.99734:99889]
∅:D[6.99734] → [6.99734:99889]
∅:D[6.99889] → [8.84763:84927]
∅:D[9.58923] → [6.100053:100517]
∅:D[4.58660] → [6.100053:100517]
∅:D[8.84927] → [6.100053:100517]
∅:D[6.100053] → [6.100053:100517]
∅:D[27.29369] → [7.31807:31953]
∅:D[4.58815] → [7.31807:31953]
∅:D[34.22915] → [7.31807:31953]
∅:D[38.9077] → [7.31807:31953]
∅:D[6.100671] → [7.31807:31953]
∅:D[7.31953] → [8.84928:85076]
∅:D[9.59072] → [7.31954:32108]
∅:D[4.58964] → [7.31954:32108]
∅:D[10.48993] → [7.31954:32108]
∅:D[12.37873] → [7.31954:32108]
∅:D[8.85076] → [7.31954:32108]
∅:D[14.39848] → [7.31954:32108]
∅:D[14.39848] → [6.101119:101417]
∅:D[7.32108] → [6.101119:101417]
∅:D[6.101119] → [6.101119:101417]
∅:D[27.29517] → [6.101720:102169]
∅:D[4.59268] → [6.101720:102169]
∅:D[34.23063] → [6.101720:102169]
∅:D[38.9225] → [6.101720:102169]
∅:D[6.101720] → [6.101720:102169]
∅:D[6.102169] → [2.77318:77467]
∅:D[25.40524] → [6.102318:102642]
∅:D[4.59418] → [6.102318:102642]
∅:D[2.77467] → [6.102318:102642]
∅:D[8.85226] → [6.102318:102642]
∅:D[6.102318] → [6.102318:102642]
∅:D[6.102642] → [8.85227:85381]
∅:D[9.59227] → [6.102796:102967]
∅:D[4.59573] → [6.102796:102967]
∅:D[7.32263] → [6.102796:102967]
∅:D[8.85381] → [6.102796:102967]
∅:D[6.102796] → [6.102796:102967]
∅:D[6.102967] → [7.32264:32415]
∅:D[7.32415] → [6.103118:103570]
∅:D[6.103118] → [6.103118:103570]
∅:D[6.103570] → [7.32416:32568]
∅:D[7.32568] → [8.85382:85538]
```
[[package]]
name = "sha-1"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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)",
 "fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "sha2"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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)",
 "fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "sha3"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "block-buffer 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "digest 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "keccak 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "opaque-debug 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "signal-hook"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "arc-swap 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "siphasher"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "slab"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "smallvec"
version = "0.6.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "socket2"
version = "0.3.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[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"
[[package]]
name = "string_cache"
version = "0.7.3"
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)",
 "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)",
 "precomputed-hash 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.89 (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)",
]
[[package]]
name = "string_cache_codegen"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "string_cache_shared 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "string_cache_shared"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "strsim"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "subtle"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "syn"
version = "0.11.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
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)",
]
[[package]]
name = "syn"
version = "0.15.27"
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.11 (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"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "synstructure"
version = "0.10.1"
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.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "syn 0.15.27 (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 = "tempfile"
version = "3.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (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.51 (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.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tendril"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "futf 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "mac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "utf-8 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "termcolor"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "wincolor 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "termion"
version = "1.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "libc 0.2.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "textwrap"
version = "0.10.0"
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.49 (registry+https://github.com/rust-lang/crates.io-index)",
 "redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio"
version = "0.1.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "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.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (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.3 (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.12 (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)",
 "tokio-uds 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-channel"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-codec"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-current-thread"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-executor"
version = "0.1.6"
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)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-fs"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "futures 0.1.25 (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.12 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-io"
version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-reactor"
version = "0.1.9"
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)",
 "futures 0.1.25 (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)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-io 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-sync 0.1.3 (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.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (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.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)",
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-sync"
version = "0.1.3"
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.25 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-tcp"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
]
[[package]]
name = "tokio-threadpool"
version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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.25 (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.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-timer"
version = "0.2.10"
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)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "tokio-tls"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "futures 0.1.25 (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)",
]
[[package]]
name = "tokio-udp"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
]
[[package]]
name = "tokio-uds"
version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
 "futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)",
 "iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "libc 0.2.49 (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)",
]
[[package]]
name = "tokio-xmpp"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "bytes 0.4.11 (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.25 (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.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-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)",
]
[[package]]
name = "toml"
version = "0.4.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "serde 1.0.89 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "trust-dns-proto"
version = "0.6.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "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.25 (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.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-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)",
]
[[package]]
name = "trust-dns-resolver"
version = "0.10.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cfg-if 0.1.6 (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.25 (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)",
 "lru-cache 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "resolv-conf 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
 "tokio 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
 "trust-dns-proto 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "try-lock"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "try_from"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "typenum"
version = "1.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "ucd-util"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "unicode-bidi"
version = "0.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "matches 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "unicode-normalization"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "unicode-width"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "unicode-xid"
version = "0.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "unicode-xid"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "url"
version = "1.7.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "idna 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 "matches 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "percent-encoding 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "utf-8"
version = "0.7.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "utf8-ranges"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "vcpkg"
version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "vec_map"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "want"
version = "0.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "futures 0.1.25 (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)",
]
[[package]]
name = "widestring"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "winapi"
version = "0.2.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "winapi"
version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "winapi-build"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "winapi-i686-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "winapi-util"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "winapi-x86_64-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "wincolor"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi-util 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "winreg"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "winutil"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "ws2_32-sys"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "xml5ever"
version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "mac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "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)",
]
[metadata]
"checksum MacTypes-sys 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "eaf9f0d0b1cc33a4d2aee14fb4b2eac03462ef4db29c8ac4057327d8a71ad86f"
"checksum aho-corasick 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "81ce3d38065e618af2d7b77e10c5ad9a069859b4be3c2250f674af3840d9c8a5"
"checksum ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
"checksum arc-swap 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1025aeae2b664ca0ea726a89d574fe8f4e77dd712d443236ad1de00379450cf6"
"checksum arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "92c7fb76bc8826a8b33b4ee5bb07a247a81e76764ab4d55e8f73e3a4d8808c71"
"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.14 (registry+https://github.com/rust-lang/crates.io-index)" = "cd5a90e2b463010cd0e0ce9a11d4a9d5d58d9f41d4a6ba3dcaf9e68b466e88b4"
"checksum backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)" = "797c830ac25ccc92a7f8a7b9862bde440715531514594a6154e3d4a54dd769b6"
"checksum base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0b25d992356d2eb0ed82172f5248873db5560c4721f564b13cb5193bda5e668e"
"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"
"checksum byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
"checksum byteorder 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a019b10a2a7cdeb292db131fc8113e57ea2a908f6e7894b0c3c671893b65dbeb"
"checksum bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "40ade3d27603c2cb345eb0912aec461a6dec7e06a4ae48589904e808335c7afa"
"checksum case 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e88b166b48e29667f5443df64df3c61dc07dc2b1a0b0d231800e07f09a33ecc1"
"checksum cc 1.0.30 (registry+https://github.com/rust-lang/crates.io-index)" = "d01c69d08ff207f231f07196e30f84c70f1c815b04f980f8b7b01ff01f05eb92"
"checksum cfg-if 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "082bb9b28e00d3c9d39cc03e64ce4cea0f1bb9b3fde493f0cbc008472d22bdf4"
"checksum chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "45912881121cb26fad7c38c17ba7daa18764771836b34fab7d3fbd93ed633878"
"checksum clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b957d88f4b6a63b9d70d5f454ac8011819c6efa7727858f458ab71c756ce2d3e"
"checksum cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
"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"
"checksum crypto-mac 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4434400df11d95d556bac068ddfedd482915eb18fe8bea89bc80b6e4b1c179e5"
"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.0 (registry+https://github.com/rust-lang/crates.io-index)" = "afb070faf94c85d17d50ca44f6ad076bce18ae92f0037d350947240a36e9d42e"
"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"
"checksum fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
"checksum fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "2fad85553e09a6f881f739c29f0b00b0f01357c743266d478b68951ce23285f3"
"checksum foreign-types 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
"checksum foreign-types-shared 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
"checksum fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
"checksum fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
"checksum fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
"checksum futf 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "7c9c1ce3fa9336301af935ab852c437817d14cd33690446569392e65170aac3b"
"checksum futures 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)" = "49e7653e374fe0d0c12de4250f0bdb60680b8c80eed558c5c7538eec9c89e21b"
"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.16 (registry+https://github.com/rust-lang/crates.io-index)" = "ddb2b25a33e231484694267af28fec74ac63b5ccf51ee2065a5e313b834d836e"
"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.16 (registry+https://github.com/rust-lang/crates.io-index)" = "fe67e3678f2827030e89cc4b9e7ecd16d52f132c0b940ab5005f88e821500f6a"
"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.25 (registry+https://github.com/rust-lang/crates.io-index)" = "7d5b6658b016965ae301fa995306db965c93677880ea70765a84235a96eae896"
"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"
"checksum keccak 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "67c21572b4949434e4fc1e1978b99c5f77064153c59d998bf13ecd96fb5ecba7"
"checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
"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.49 (registry+https://github.com/rust-lang/crates.io-index)" = "413f3dfc802c5dc91dc570b05125b6cda9855edfaa9825c9849807876376e70e"
"checksum linked-hash-map 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7860ec297f7008ff7a1e3382d7f7e1dcd69efc94751a2284bafc3d013c2aa939"
"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"
"checksum lru-cache 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4d06ff7ff06f729ce5f4e227876cb88d10bc59cd4ae1e09fbb2bde15c850dc21"
"checksum mac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"
"checksum markup5ever 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "897636f9850c3eef4905a5540683ed53dc9393860f0846cab2c2ddf9939862ff"
"checksum matches 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"
"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"
"checksum miow 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8c1f2f3b1cf331de6896aabf6e9d55dca90356cc9960cca7eaaf408a355ae919"
"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.19 (registry+https://github.com/rust-lang/crates.io-index)" = "84321fb9004c3bce5611188a644d6171f895fa2889d155927d528782edb21c5d"
"checksum openssl-probe 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "77af24da69f9d9341038eba93a073b1fdaaa1b788221b00a69bce9e762cb32de"
"checksum openssl-sys 0.9.42 (registry+https://github.com/rust-lang/crates.io-index)" = "cb534d752bf98cf363b473950659ac2546517f9c6be9723771614ab3f03bbc9e"
"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"
"checksum pbkdf2 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "006c038a43a45995a9670da19e67600114740e8511d4333bf97a56e66a7542d9"
"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"
"checksum precomputed-hash 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
"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.11 (registry+https://github.com/rust-lang/crates.io-index)" = "cdd8e04bd9c52e0342b406469d494fcb033be4bdbe5c606016defbb1681411e1"
"checksum rand 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c618c47cd3ebd209790115ab837de41425723956ad3ce2e6a7f09890947cacb9"
"checksum rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "6d71dacdc3c88c1fde3885a3be3fbab9f35724e6ce99467f7d9c5026132184ca"
"checksum rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "556d3a1ca6600bfcbab7c7c91ccb085ac7fbbcd70e008a98742e7847f4f7bcef"
"checksum rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
"checksum rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d0e7a549d590831370895ab7ba4ea0c1b6b011d106b5ff2da6eee112615e6dc0"
"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"
"checksum rand_os 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b7c690732391ae0abafced5015ffb53656abfaec61b342290e5eb56b286a679d"
"checksum rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "abf9b09b01790cfe0364f52bf32995ea3c39f4d2dd011eac241d2914146d0b44"
"checksum rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cbf7e9e623549b0e21f6e97cf8ecf247c1a8fd2e8a992ae265314300b2455d5c"
"checksum rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
"checksum redox_syscall 0.1.51 (registry+https://github.com/rust-lang/crates.io-index)" = "423e376fffca3dfa06c9e9790a9ccd282fafb3cc6e6397d01dbf64f9bacc6b85"
"checksum redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7e891cfe48e9100a70a3b6eb652fef28920c117d366339687bd5576160db0f76"
"checksum regex 1.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "53ee8cfdddb2e0291adfb9f13d31d3bbe0a03c9a402c01b1e24188d86c35b24f"
"checksum regex-syntax 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "8c2f35eedad5295fdf00a63d7d4b238135723f92b434ec06774dad15c7ab0861"
"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.13 (registry+https://github.com/rust-lang/crates.io-index)" = "adacaae16d02b6ec37fdc7acfcddf365978de76d1983d3ee22afc260e1ca9619"
"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"
"checksum sasl 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e457758c85b736bbad56dc099406cd2a9c19554cf81880dba7a51d092929e600"
"checksum schannel 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "f2f6abf258d99c3c1c5c2131d99d064e94b7b3dd5f416483057f308fea253339"
"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.89 (registry+https://github.com/rust-lang/crates.io-index)" = "92514fb95f900c9b5126e32d020f5c6d40564c27a5ea6d1d7d9f157a96623560"
"checksum serde_derive 1.0.89 (registry+https://github.com/rust-lang/crates.io-index)" = "bb6eabf4b5914e88e24eea240bb7c9f9a2cbc1bbbe8d961d381975ec3c6b806c"
"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"
"checksum slab 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
"checksum smallvec 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "c4488ae950c49d403731982257768f48fada354a5203fe81f9bb6f43ca9002be"
"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"
"checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550"
"checksum subtle 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2d67a5a62ba6e01cb2192ff309324cb4875d0c451d55fe2319433abe7a05a8ee"
"checksum syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)" = "d3b891b9015c88c576343b9b3e41c2c11a51c219ef067b264bd9c8aa9b441dad"
"checksum syn 0.15.27 (registry+https://github.com/rust-lang/crates.io-index)" = "525bd55255f03c816e5d7f615587bd13030c7103354fadb104993dcee6a788ec"
"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"
"checksum tendril 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "707feda9f2582d5d680d733e38755547a3e8fb471e7ba11452ecfd9ce93a5d3b"
"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"
"checksum textwrap 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "307686869c93e71f94da64286f9a9524c0f308a9e1c87a583de8e9c9039ad3f6"
"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.16 (registry+https://github.com/rust-lang/crates.io-index)" = "fcaabb3cec70485d0df6e9454fe514393ad1c4070dee8915f11041e95630b230"
"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.5 (registry+https://github.com/rust-lang/crates.io-index)" = "c756b04680eea21902a46fca4e9f410a2332c04995af590e07ff262e2193a9a3"
"checksum tokio-executor 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "30c6dbf2d1ad1de300b393910e8a3aa272b724a400b6531da03eed99e329fbf0"
"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.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1bf2b9dac2a0509b5cfd1df5aa25eafacb616a42a491a13604d6bbeab4486363"
"checksum tokio-tcp 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1d14b10654be682ac43efee27401d792507e30fd8d26389e1da3b185de2e4119"
"checksum tokio-threadpool 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "742e511f6ce2298aeb86fc9ea0d8df81c2388c6ebae3dc8a7316e8c9df0df801"
"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-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.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "758664fc71a3a69038656bee8b6be6477d2a6c315a6b81f7081f591bffa4111f"
"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"
"checksum unicode-bidi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "49f2bd0c6468a8230e1db229cff8029217cf623c767ea5d60bfbd42729ea54d5"
"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"
"checksum utf-8 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "05e42f7c18b8f902290b009cde6d651262f956c98bc51bca4cd1d511c9cd85c7"
"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"
"checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
"checksum winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "92c1eb33641e276cfa214a0522acad57be5c56b10cb348b3c5117db75f3ac4b0"
"checksum winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
"checksum winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
"checksum winapi-util 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7168bab6e1daee33b4557efd0e95d5ca70a03706d39fa5f3fe7a236f584b03c9"
"checksum winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
"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"
"checksum ws2_32-sys 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e"
"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"
```

Ignore .orig files

Dependencies

In channels

Change contents

Replacement in src/xmpp/xmpp_connection.rs at line 0 [3.21]

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

Deletion in src/main.rs at line 0 [5.17]

Replacement in src/main.rs at line 1 [5.17]

Deletion in README.md at line 0 [5.76]

Deletion in Cargo.toml at line 6 [5.11995]

Deletion in Cargo.toml at line 8 [5.11995]

Deletion in Cargo.lock at line 0 [5.12201]

Deletion in Cargo.lock at line 1 [5.12201]

Deletion in Cargo.lock at line 3 [5.12201]

Deletion in Cargo.lock at line 4 [5.12201]